Update app.py

app.py

@@ -41,8 +41,8 @@ logging.basicConfig(
     filename='transcript_parser.log'
 )
 
-# Model configuration - Only DeepSeek
-MODEL_NAME = "deepseek-ai/deepseek-llm-7b"
+# Model configuration - Using smaller model
+MODEL_NAME = "deepseek-ai/deepseek-llm-1.3b"
 
 # Initialize Hugging Face API
 if HF_TOKEN:
@@ -52,14 +52,6 @@ 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):
@@ -76,7 +68,6 @@ class ModelLoader:
             if progress:
                 progress(0.1, desc="Checking GPU availability...")
             
-            # Clear CUDA cache first
             torch.cuda.empty_cache()
             
             if progress:
@@ -90,13 +81,12 @@ class ModelLoader:
             if progress:
                 progress(0.5, desc="Loading model (this may take a few minutes)...")
                 
-            # More robust model loading
             model_kwargs = {
                 "trust_remote_code": True,
                 "torch_dtype": torch.float16 if self.device == "cuda" else torch.float32,
                 "device_map": "auto" if self.device == "cuda" else None,
                 "low_cpu_mem_usage": True,
-                "offload_folder": "offload"  # For handling large models
+                "offload_folder": "offload"
             }
             
             try:
@@ -105,7 +95,6 @@ class ModelLoader:
                     **model_kwargs
                 )
             except torch.cuda.OutOfMemoryError:
-                # Fallback to CPU if GPU OOM
                 model_kwargs["device_map"] = None
                 model = AutoModelForCausalLM.from_pretrained(
                     MODEL_NAME,
@@ -113,7 +102,6 @@ class ModelLoader:
                 ).to('cpu')
                 self.device = 'cpu'
                 
-            # Verify model is responsive
             test_input = tokenizer("Test", return_tensors="pt").to(self.device)
             _ = model.generate(**test_input, max_new_tokens=1)
             
@@ -131,29 +119,27 @@ class ModelLoader:
 # Initialize model loader
 model_loader = ModelLoader()
 
+@lru_cache(maxsize=1)
+def get_model_and_tokenizer():
+    return model_loader.load_model()
+
 # ========== UTILITY FUNCTIONS ==========
 def generate_session_token() -> str:
-    """Generate a random session token for user identification."""
     alphabet = string.ascii_letters + string.digits
     return ''.join(secrets.choice(alphabet) for _ in range(SESSION_TOKEN_LENGTH))
 
 def sanitize_input(text: str) -> str:
-    """Sanitize user input to prevent XSS and injection attacks."""
     if not text:
         return ""
-    # Basic HTML escaping and removal of potentially dangerous characters
     text = html.escape(text.strip())
-    # Remove any remaining HTML tags
     text = re.sub(r'<[^>]*>', '', text)
-    # Remove potentially dangerous characters
     text = re.sub(r'[^\w\s\-.,!?@#\$%^&*()+=]', '', text)
     return text
 
 def validate_name(name: str) -> str:
-    """Validate name input."""
     name = name.strip()
     if not name:
-        raise ValueError("Name cannot be empty. Please enter your full name.")
+        raise ValueError("Name cannot be empty.")
     if len(name) > 100:
         raise ValueError("Name is too long (maximum 100 characters).")
     if any(c.isdigit() for c in name):
@@ -161,7 +147,6 @@ def validate_name(name: str) -> str:
     return name
 
 def validate_age(age: Union[int, float, str]) -> int:
-    """Validate and convert age input."""
     try:
         age_int = int(age)
         if not MIN_AGE <= age_int <= MAX_AGE:
@@ -171,7 +156,6 @@ def validate_age(age: Union[int, float, str]) -> int:
         raise ValueError("Please enter a valid age number.")
 
 def validate_file(file_obj) -> None:
-    """Validate uploaded file."""
     if not file_obj:
         raise ValueError("Please upload a file first")
     
@@ -179,24 +163,22 @@ def validate_file(file_obj) -> None:
     if file_ext not in ALLOWED_FILE_TYPES:
         raise ValueError(f"Invalid file type. Allowed types: {', '.join(ALLOWED_FILE_TYPES)}")
     
-    file_size = os.path.getsize(file_obj.name) / (1024 * 1024)  # MB
+    file_size = os.path.getsize(file_obj.name) / (1024 * 1024)
     if file_size > MAX_FILE_SIZE_MB:
         raise ValueError(f"File too large. Maximum size is {MAX_FILE_SIZE_MB}MB.")
 
 # ========== TEXT EXTRACTION FUNCTIONS ==========
 def extract_text_from_file(file_path: str, file_ext: str) -> str:
-    """Enhanced text extraction with better error handling and fallbacks."""
     text = ""
     
     try:
         if file_ext == '.pdf':
-            # First try PyMuPDF for text extraction
             try:
                 doc = fitz.open(file_path)
                 for page in doc:
                     text += page.get_text("text") + '\n'
                 if not text.strip():
-                    raise ValueError("PyMuPDF returned empty text - the PDF may be image-based")
+                    raise ValueError("PyMuPDF returned empty text")
             except Exception as e:
                 logging.warning(f"PyMuPDF failed: {str(e)}. Trying OCR fallback...")
                 text = extract_text_from_pdf_with_ocr(file_path)
@@ -204,56 +186,44 @@ def extract_text_from_file(file_path: str, file_ext: str) -> str:
         elif file_ext in ['.png', '.jpg', '.jpeg']:
             text = extract_text_with_ocr(file_path)
             
-        # Clean up the extracted text
         text = clean_extracted_text(text)
         
         if not text.strip():
-            raise ValueError("No text could be extracted. Please ensure the file is clear and readable.")
+            raise ValueError("No text could be extracted.")
             
         return text
     
     except Exception as e:
         logging.error(f"Text extraction error: {str(e)}")
-        raise gr.Error(f"Failed to extract text: {str(e)}\n\nTIPS:\n1. For PDFs, try saving as a different PDF format\n2. For images, ensure they are high-quality and well-lit\n3. Try cropping to just the transcript area")
+        raise gr.Error(f"Failed to extract text: {str(e)}")
 
 def extract_text_from_pdf_with_ocr(file_path: str) -> str:
-    """Fallback PDF text extraction using OCR."""
     text = ""
     try:
         doc = fitz.open(file_path)
         for page in doc:
             pix = page.get_pixmap()
             img = Image.open(io.BytesIO(pix.tobytes()))
-            # Preprocess image for better OCR
-            img = img.convert('L')  # Grayscale
-            img = img.point(lambda x: 0 if x < 128 else 255)  # Binarize
+            img = img.convert('L')
+            img = img.point(lambda x: 0 if x < 128 else 255)
             text += pytesseract.image_to_string(img, config='--psm 6 --oem 3') + '\n'
     except Exception as e:
-        raise ValueError(f"PDF OCR failed: {str(e)}. The PDF may be password protected or corrupted.")
+        raise ValueError(f"PDF OCR failed: {str(e)}")
     return text
 
 def extract_text_with_ocr(file_path: str) -> str:
-    """Extract text from image files using OCR with preprocessing."""
     try:
         image = Image.open(file_path)
-        
-        # Enhanced preprocessing
-        image = image.convert('L')  # Convert to grayscale
-        image = image.point(lambda x: 0 if x < 128 else 255, '1')  # Thresholding
-        
-        # Custom Tesseract configuration
+        image = image.convert('L')
+        image = image.point(lambda x: 0 if x < 128 else 255, '1')
         custom_config = r'--oem 3 --psm 6'
         text = pytesseract.image_to_string(image, config=custom_config)
         return text
     except Exception as e:
-        raise ValueError(f"OCR processing failed: {str(e)}. Please ensure the image is clear and not blurry.")
+        raise ValueError(f"OCR processing failed: {str(e)}")
 
 def clean_extracted_text(text: str) -> str:
-    """Clean and normalize the extracted text."""
-    # Remove multiple spaces and newlines
     text = re.sub(r'\s+', ' ', text).strip()
-    
-    # Fix common OCR errors
     replacements = {
         '|': 'I',
         '‘': "'",
@@ -263,38 +233,16 @@ def clean_extracted_text(text: str) -> str:
         'fi': 'fi',
         'fl': 'fl'
     }
-    
     for wrong, right in replacements.items():
         text = text.replace(wrong, right)
-    
     return text
 
 def remove_sensitive_info(text: str) -> str:
-    """Remove potentially sensitive information from transcript text."""
-    # Remove social security numbers
     text = re.sub(r'\b\d{3}-\d{2}-\d{4}\b', '[REDACTED]', text)
-    # Remove student IDs (assuming 6-9 digit numbers)
     text = re.sub(r'\b\d{6,9}\b', '[ID]', text)
-    # Remove email addresses
     text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', text)
     return text
 
-def validate_parsed_data(data: Dict) -> bool:
-    """Validate the structure of parsed transcript data"""
-    required_student_fields = ['name', 'current_grade']
-    required_course_fields = ['description', 'credits']
-    
-    if 'student_info' not in data:
-        return False
-    if not all(field in data['student_info'] for field in required_student_fields):
-        return False
-    if 'course_history' not in data or not isinstance(data['course_history'], list):
-        return False
-    if len(data['course_history']) > 0:
-        if not all(field in data['course_history'][0] for field in required_course_fields):
-            return False
-    return True
-
 # ========== TRANSCRIPT PARSING ==========
 class TranscriptParser:
     def __init__(self):
@@ -305,353 +253,45 @@ class TranscriptParser:
         self.graduation_status = {}
         
     def parse_transcript(self, text: str) -> Dict:
-        """Parse Miami-Dade formatted transcripts with updated regex patterns."""
+        """Simplified transcript parser that extracts key information"""
         try:
-            # First try structured parsing for Miami-Dade format
-            if "Graduation Progress Summary" in text or "Miami-Dade" in text:
-                return self._parse_miami_dade_format(text)
-            else:
-                # Fall back to AI parsing if not Miami-Dade format
-                return parse_transcript_with_ai_fallback(text)
-                
-        except Exception as e:
-            logging.error(f"Error parsing transcript: {str(e)}")
-            raise ValueError(f"Couldn't parse transcript: {str(e)}")
-
-    def _parse_miami_dade_format(self, text: str, strict_mode: bool = False) -> Dict:
-        """Parse Miami-Dade County Public Schools transcripts."""
-        # Initialize PDF reader from text (simulating the PDF structure)
-        lines = [line.strip() for line in text.split('\n') if line.strip()]
-        
-        # Initialize data structure
-        data = {
-            'student_info': {},
-            'graduation_requirements': [],
-            'course_history': [],
-            'summary': {},
-            'format': 'miami_dade'  # Add format identifier
-        }
-        
-        # Parse student information
-        student_info_found = False
-        for i, line in enumerate(lines):
-            if "DORAL ACADEMY HIGH SCHOOL" in line:
-                # School info line
-                school_info = line.split('|')
-                if len(school_info) > 1:
-                    data['student_info']['school'] = school_info[1].strip()
-                    data['student_info']['district'] = school_info[2].strip() if len(school_info) > 2 else ''
-                
-                # Student ID and name line
-                if i+1 < len(lines):
-                    student_line = lines[i+1].split('-')
-                    if len(student_line) > 1:
-                        name_parts = student_line[1].split(',')
-                        if len(name_parts) > 1:
-                            data['student_info']['student_id'] = student_line[0].strip()
-                            data['student_info']['student_name'] = name_parts[1].strip() + " " + name_parts[0].strip()
-                
-                # Academic info line
-                if i+2 < len(lines):
-                    academic_info = lines[i+2].split('|')
-                    if len(academic_info) > 1:
-                        data['student_info']['current_grade'] = academic_info[1].split(':')[1].strip() if ':' in academic_info[1] else academic_info[1].strip()
-                        if len(academic_info) > 2:
-                            data['student_info']['graduation_year'] = academic_info[2].strip()
-                        if len(academic_info) > 3:
-                            gpa_part = academic_info[3].strip()
-                            if 'Weighted GPA' in gpa_part:
-                                data['student_info']['weighted_gpa'] = gpa_part.split(':')[1].strip() if ':' in gpa_part else ''
-                            elif 'Un-weighted GPA' in gpa_part:
-                                data['student_info']['unweighted_gpa'] = gpa_part.split(':')[1].strip() if ':' in gpa_part else ''
-                        if len(academic_info) > 4:
-                            data['student_info']['community_service_date'] = academic_info[4].split(':')[1].strip() if ':' in academic_info[4] else ''
-                        if len(academic_info) > 5:
-                            data['student_info']['total_credits_earned'] = academic_info[5].split(':')[1].strip() if ':' in academic_info[5] else ''
-                
-                student_info_found = True
-                break
-        
-        if not student_info_found and strict_mode:
-            raise ValueError("Could not find student information section")
-        
-        # Parse graduation requirements
-        requirements_start = None
-        requirements_end = None
-        for i, line in enumerate(lines):
-            if "Code" in line and "Description" in line and "Required" in line:
-                requirements_start = i + 1
-            if requirements_start and "Total" in line:
-                requirements_end = i
-                break
-        
-        if requirements_start and requirements_end:
-            for line in lines[requirements_start:requirements_end]:
-                if '|' in line:
-                    parts = [p.strip() for p in line.split('|') if p.strip()]
-                    if len(parts) >= 6:
-                        req = {
-                            'code': parts[0],
-                            'description': parts[1],
-                            'required': parts[2],
-                            'waived': parts[3],
-                            'completed': parts[4],
-                            'status': parts[5]
-                        }
-                        data['graduation_requirements'].append(req)
+            parsed_data = {
+                'student_info': {},
+                'course_history': []
+            }
             
-            # Parse total line
-            if requirements_end < len(lines):
-                total_line = lines[requirements_end]
-                total_parts = [p.strip() for p in total_line.split('|') if p.strip()]
-                if len(total_parts) >= 5:
-                    data['summary']['total_required'] = total_parts[1]
-                    data['summary']['total_waived'] = total_parts[2]
-                    data['summary']['total_completed'] = total_parts[3]
-                    data['summary']['completion_percentage'] = total_parts[4]
-        
-        # Parse course history
-        course_history_start = None
-        for i, line in enumerate(lines):
-            if "Requirement" in line and "School Year" in line and "GradeLv1" in line:
-                course_history_start = i + 1
-                break
-        
-        if course_history_start:
-            current_requirement = None
-            for line in lines[course_history_start:]:
-                if '|' in line:
-                    parts = [p.strip() for p in line.split('|') if p.strip()]
-                    
-                    # Check if this is a new requirement line
-                    if len(parts) >= 2 and parts[0] and parts[0] in [req['code'] for req in data['graduation_requirements']]:
-                        current_requirement = parts[0]
-                        parts = parts[1:]  # Remove the requirement code
-                    
-                    if len(parts) >= 9:
-                        course = {
-                            'requirement': current_requirement,
-                            'school_year': parts[0],
-                            'grade_level': parts[1],
-                            'course_number': parts[2],
-                            'description': parts[3],
-                            'term': parts[4],
-                            'district_number': parts[5],
-                            'fg': parts[6],
-                            'included': parts[7],
-                            'credits': parts[8]
-                        }
-                        data['course_history'].append(course)
-        
-        # Calculate graduation status
-        try:
-            if data['summary'].get('total_required') and data['summary'].get('total_completed'):
-                graduation_status = {
-                    'total_required_credits': float(data['summary']['total_required']),
-                    'total_completed_credits': float(data['summary']['total_completed']),
-                    'percent_complete': float(data['summary']['completion_percentage'].replace('%', '')),
-                    'remaining_credits': float(data['summary']['total_required']) - float(data['summary']['total_completed']),
-                    'on_track': float(data['summary']['completion_percentage'].replace('%', '')) >= 75.0
-                }
-                data['graduation_status'] = graduation_status
-        except Exception as e:
-            if strict_mode:
-                raise ValueError(f"Error calculating graduation status: {str(e)}")
-        
-        return data
-
-def format_transcript_output(data: Dict) -> str:
-    """Enhanced formatting for transcript output with format awareness"""
-    output = []
-    
-    # Student Info Section
-    student = data.get("student_info", {})
-    output.append(f"## Student Transcript Summary\n{'='*50}")
-    output.append(f"**Name:** {student.get('name', 'Unknown')}")
-    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')}")
-    
-    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']}")
-    
-    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 req in data.get("graduation_requirements", []):
-            output.append(
-                f"- **{req['code']}**: {req['description']}\n"
-                f"  Required: {req['required']} | Completed: {req['completed']} | "
-                f"Status: {req['status']}"
-            )
-        output.append("")
-    
-    # Current Courses
-    if any(c.get('credits', '') == 'inProgress' for c in data.get("course_history", [])):
-        output.append("## Current Courses (In Progress)\n" + '='*50)
-        for course in data["course_history"]:
-            if course.get('credits', '') == 'inProgress':
-                output.append(
-                    f"- **{course['course_number']} {course['description']}**\n"
-                    f"  Category: {course['requirement']} | "
-                    f"Grade Level: {course['grade_level']} | "
-                    f"Term: {course['term']} | Credits: {course['credits']}"
-                )
-        output.append("")
-    
-    # Course History by Year
-    courses_by_year = defaultdict(list)
-    for course in data.get("course_history", []):
-        if course.get("school_year"):
-            courses_by_year[course["school_year"]].append(course)
-    
-    if courses_by_year:
-        output.append("## Course History\n" + '='*50)
-        for year in sorted(courses_by_year.keys()):
-            output.append(f"\n### {year}")
-            for course in courses_by_year[year]:
-                output.append(
-                    f"- **{course.get('course_number', '')} {course.get('description', 'Unnamed course')}**\n"
-                    f"  Subject: {course.get('requirement', 'N/A')} | "
-                    f"Grade: {course.get('fg', 'N/A')} | "
-                    f"Credits: {course.get('credits', 'N/A')}"
-                )
-    
-    return '\n'.join(output)
-
-def parse_transcript_with_ai_fallback(text: str, progress=gr.Progress()) -> Dict:
-    """More robust AI parsing with better error handling"""
-    try:
-        text = remove_sensitive_info(text[:20000])  # Increased limit
-        
-        # Improved prompt with examples
-        prompt = f"""Extract academic transcript data as JSON. Follow this structure:
-        
-        Example Input:
-        Student ID: 1234567 Name: DOE, JOHN Current Grade: 12 YOG: 2024
-        Unweighted GPA: 3.5 Weighted GPA: 4.2 Total Credits: 24.5
-        
-        Example Output:
-        {{
-            "student_info": {{
-                "name": "John Doe",
-                "id": "1234567",
-                "current_grade": "12",
-                "graduation_year": "2024",
-                "unweighted_gpa": 3.5,
-                "weighted_gpa": 4.2,
-                "total_credits": 24.5
-            }},
-            "course_history": [
-                {{
-                    "course_code": "MATH101",
-                    "description": "Algebra I",
-                    "grade": "A",
-                    "credits": 1.0,
-                    "school_year": "2022-2023"
-                }}
-            ]
-        }}
-        
-        Actual Transcript:
-        {text}
-        """
-        
-        if progress:
-            progress(0.3, desc="Processing with AI...")
-        
-        model, tokenizer = get_model_and_tokenizer()
-        if model is None:
-            raise ValueError("Model not loaded")
+            # Extract student information
+            name_match = re.search(r'(?:Name|Student)[:\s]+([A-Za-z,\s]+)', text, re.IGNORECASE)
+            if name_match:
+                parsed_data['student_info']['name'] = name_match.group(1).strip()
             
-        inputs = tokenizer(prompt, return_tensors="pt", truncation=True).to(model_loader.device)
-        
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=2500,
-            temperature=0.3,  # Lower for more consistent results
-            do_sample=True,
-            top_p=0.9,
-            repetition_penalty=1.2
-        )
-        
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # More robust JSON extraction
-        try:
-            if '```json' in response:
-                json_str = response.split('```json')[1].split('```')[0].strip()
-            else:
-                json_str = response.split('{', 1)[1].rsplit('}', 1)[0]
-                json_str = '{' + json_str + '}'
-                
-            parsed_data = json.loads(json_str)
+            id_match = re.search(r'(?:ID|Student\s*ID)[:\s]+([A-Za-z0-9-]+)', text, re.IGNORECASE)
+            if id_match:
+                parsed_data['student_info']['id'] = id_match.group(1).strip()
             
-            # Validate required fields
-            if not all(k in parsed_data for k in ["student_info", "course_history"]):
-                raise ValueError("Missing required fields in AI response")
-                
-            return parsed_data
+            gpa_match = re.search(r'(?:GPA|Grade\s*Point\s*Average)[:\s]+([0-9.]+)', text, re.IGNORECASE)
+            if gpa_match:
+                parsed_data['student_info']['gpa'] = float(gpa_match.group(1))
             
-        except Exception as e:
-            logging.error(f"JSON parsing failed: {str(e)}")
-            raise ValueError(f"AI returned invalid format. Please try again.")
+            # Extract courses (simplified pattern)
+            course_pattern = r'([A-Z]{2,4}\s?\d{3})\s+(.*?)\s+([A-F][+-]?)\s+([0-9.]+)'
+            courses = re.findall(course_pattern, text)
+            for course in courses:
+                parsed_data['course_history'].append({
+                    'course_code': course[0],
+                    'description': course[1],
+                    'grade': course[2],
+                    'credits': float(course[3])
+                })
             
-    except Exception as e:
-        logging.error(f"AI parsing error: {str(e)}")
-        raise gr.Error(f"Failed to parse transcript: {str(e)}")
-
-def parse_transcript_with_ai(text: str, progress=gr.Progress()) -> Dict:
-    """Enhanced AI parsing with fallback to structured parsing"""
-    try:
-        # First try structured parsing
-        if progress:
-            progress(0.1, desc="Attempting structured parsing...")
-        
-        parser = TranscriptParser()
-        parsed_data = parser.parse_transcript(text)
-        
-        # Validate the parsed data
-        if not validate_parsed_data(parsed_data):
-            raise ValueError("Structured parsing returned incomplete data")
+            return parsed_data
             
-        if progress:
-            progress(0.8, desc="Formatting results...")
-        
-        return parsed_data
-        
-    except Exception as e:
-        logging.warning(f"Structured parsing failed, falling back to AI: {str(e)}")
-        
-        # Fall back to AI parsing if structured parsing fails
-        return parse_transcript_with_ai_fallback(text, progress)
-
-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)
+        except Exception as e:
+            logging.error(f"Error parsing transcript: {str(e)}")
+            raise ValueError(f"Couldn't parse transcript: {str(e)}")
 
 def parse_transcript(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Dict]]:
-    """Main function to parse transcript files with better error handling"""
+    """Process transcript file and return simple confirmation"""
     try:
         if not file_obj:
             raise ValueError("Please upload a file first")
@@ -659,46 +299,29 @@ def parse_transcript(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Di
         validate_file(file_obj)
         file_ext = os.path.splitext(file_obj.name)[1].lower()
         
-        # Extract text from file with better error reporting
         if progress:
             progress(0.2, desc="Extracting text from file...")
         
         text = extract_text_from_file(file_obj.name, file_ext)
         
         if not text.strip():
-            raise ValueError("No text could be extracted from the file. The file may be corrupted or in an unsupported format.")
+            raise ValueError("No text could be extracted from the file.")
         
-        # Try structured parsing first
         if progress:
-            progress(0.4, desc="Attempting structured parsing...")
+            progress(0.5, desc="Parsing transcript...")
             
         parser = TranscriptParser()
-        try:
-            parsed_data = parser.parse_transcript(text)
-            if validate_parsed_data(parsed_data):
-                if progress:
-                    progress(0.9, desc="Formatting results...")
-                return format_transcript_output(parsed_data), parsed_data
-        except Exception as e:
-            logging.warning(f"Structured parsing failed: {str(e)}")
+        parsed_data = parser.parse_transcript(text)
         
-        # Fall back to AI if structured fails
-        if progress:
-            progress(0.5, desc="Using AI analysis...")
-            
-        parsed_data = parse_transcript_with_ai_fallback(text, progress)
-        return format_transcript_output(parsed_data), parsed_data
+        # Return simple confirmation message
+        confirmation = "Transcript processed successfully."
+        if 'gpa' in parsed_data.get('student_info', {}):
+            confirmation += f"\nGPA detected: {parsed_data['student_info']['gpa']}"
+        
+        return confirmation, parsed_data
         
     except Exception as e:
         error_msg = f"Error processing transcript: {str(e)}"
-        # Add specific troubleshooting tips
-        if "PDF" in str(e):
-            error_msg += "\n\nTIPS:\n1. Try converting to image (screenshot)\n2. Ensure text is selectable in PDF\n3. Try a different PDF reader"
-        elif "image" in str(e).lower():
-            error_msg += "\n\nTIPS:\n1. Use high contrast images\n2. Crop to just the transcript\n3. Ensure good lighting"
-        elif "AI" in str(e):
-            error_msg += "\n\nTIPS:\n1. Try a smaller section of the transcript\n2. Check for sensitive info that may be redacted\n3. Try again later"
-            
         logging.error(error_msg)
         return error_msg, None
 
@@ -811,8 +434,8 @@ class LearningStyleQuiz:
         }
     
     def evaluate_quiz(self, *answers) -> str:
-        """Evaluate quiz answers and generate enhanced results."""
-        answers = list(answers)  # Convert tuple to list
+        """Evaluate quiz answers and return learning style results"""
+        answers = list(answers)
         if len(answers) != len(self.questions):
             raise gr.Error("Please answer all questions before submitting")
         
@@ -820,7 +443,7 @@ class LearningStyleQuiz:
         
         for i, answer in enumerate(answers):
             if not answer:
-                continue  # Skip unanswered questions
+                continue
                 
             for j, style in enumerate(self.learning_styles):
                 if answer == self.options[i][j]:
@@ -834,7 +457,6 @@ class LearningStyleQuiz:
         percentages = {style: (score/total_answered)*100 for style, score in scores.items()}
         sorted_styles = sorted(scores.items(), key=lambda x: x[1], reverse=True)
         
-        # Generate enhanced results report
         result = "## Your Learning Style Results\n\n"
         result += "### Scores:\n"
         for style, score in sorted_styles:
@@ -860,7 +482,6 @@ class LearningStyleQuiz:
             for career in style_info['careers'][:6]:
                 result += f"- {career}\n"
             
-            # Add complementary strategies
             complementary = [s for s in sorted_styles if s[0] != primary_style][0][0]
             result += f"\nYou might also benefit from some **{complementary}** strategies:\n"
             for tip in self.learning_styles[complementary]['tips'][:3]:
@@ -883,7 +504,6 @@ class LearningStyleQuiz:
         
         return result
 
-# Initialize quiz instance
 learning_style_quiz = LearningStyleQuiz()
 
 # ========== PROFILE MANAGEMENT ==========
@@ -894,13 +514,10 @@ class ProfileManager:
         self.current_session = None
     
     def set_session(self, session_token: str) -> None:
-        """Set the current session token."""
         self.current_session = session_token
     
     def get_profile_path(self, name: str) -> Path:
-        """Get profile path with session token if available."""
         if self.current_session:
-            # 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"
@@ -910,22 +527,9 @@ class ProfileManager:
                     movie: str, movie_reason: str, show: str, show_reason: str, 
                     book: str, book_reason: str, character: str, character_reason: str, 
                     blog: str) -> str:
-        """Save student profile with better validation messages"""
         try:
-            # Validate required fields with specific messages
-            if not name.strip():
-                raise ValueError("Name cannot be empty. Please enter your full name.")
-            if len(name) > 100:
-                raise ValueError("Name is too long (maximum 100 characters).")
-            if any(c.isdigit() for c in name):
-                raise ValueError("Name cannot contain numbers.")
-            
-            try:
-                age_int = int(age)
-                if not MIN_AGE <= age_int <= MAX_AGE:
-                    raise ValueError(f"Age must be between {MIN_AGE} and {MAX_AGE}.")
-            except (ValueError, TypeError):
-                raise ValueError("Please enter a valid age number.")
+            name = validate_name(name)
+            age = validate_age(age)
             
             if not interests.strip():
                 raise ValueError("Please describe at least one interest or hobby.")
@@ -933,11 +537,9 @@ class ProfileManager:
             if not transcript:
                 raise ValueError("Please complete the transcript analysis first.")
             
-            # Validate learning style quiz completion
             if not learning_style or "Your primary learning style is:" not in learning_style:
                 raise ValueError("Please complete the learning style quiz first.")
             
-            # Prepare favorites data
             favorites = {
                 "movie": sanitize_input(movie),
                 "movie_reason": sanitize_input(movie_reason),
@@ -949,26 +551,23 @@ class ProfileManager:
                 "character_reason": sanitize_input(character_reason)
             }
             
-            # Prepare full profile data
             data = {
                 "name": name,
-                "age": age_int,
+                "age": age,
                 "interests": sanitize_input(interests),
-                "transcript": transcript if transcript else {},
-                "learning_style": learning_style if learning_style else "Not assessed",
+                "transcript": transcript,
+                "learning_style": learning_style,
                 "favorites": favorites,
                 "blog": sanitize_input(blog) if blog else "",
                 "session_token": self.current_session,
                 "last_updated": time.time()
             }
             
-            # Save to JSON file
             filepath = self.get_profile_path(name)
             
             with open(filepath, "w", encoding='utf-8') as f:
                 json.dump(data, f, indent=2, ensure_ascii=False)
             
-            # Upload to HF Hub if token is available
             if HF_TOKEN and 'hf_api' in globals():
                 try:
                     hf_api.upload_file(
@@ -980,14 +579,17 @@ class ProfileManager:
                 except Exception as e:
                     logging.error(f"Failed to upload to HF Hub: {str(e)}")
             
-            return self._generate_profile_summary(data)
+            # Return simple confirmation with GPA if available
+            confirmation = f"Profile saved successfully for {name}."
+            if 'gpa' in data.get('transcript', {}).get('student_info', {}):
+                confirmation += f"\nGPA: {data['transcript']['student_info']['gpa']}"
+            return confirmation
         
         except Exception as e:
             logging.error(f"Profile validation error: {str(e)}")
             raise gr.Error(f"Couldn't save profile: {str(e)}")
-    
+
     def load_profile(self, name: str = None, session_token: str = None) -> Dict:
-        """Load profile by name or return the first one found."""
         try:
             if session_token:
                 profile_pattern = f"*{session_token}_profile.json"
@@ -999,7 +601,6 @@ class ProfileManager:
                 return {}
             
             if name:
-                # Find profile by name (hashed)
                 name_hash = hashlib.sha256(name.encode()).hexdigest()[:16]
                 if session_token:
                     profile_file = self.profiles_dir / f"{name_hash}_{session_token}_profile.json"
@@ -1007,7 +608,6 @@ class ProfileManager:
                     profile_file = self.profiles_dir / f"{name_hash}_profile.json"
                 
                 if not profile_file.exists():
-                    # Try loading from HF Hub
                     if HF_TOKEN and 'hf_api' in globals():
                         try:
                             hf_api.download_file(
@@ -1021,12 +621,10 @@ class ProfileManager:
                     else:
                         raise gr.Error(f"No profile found for {name}")
             else:
-                # Load the first profile found
                 profile_file = profiles[0]
             
             with open(profile_file, "r", encoding='utf-8') as 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
@@ -1036,13 +634,11 @@ class ProfileManager:
             return {}
     
     def list_profiles(self, session_token: str = None) -> List[str]:
-        """List all available profile names for the current session."""
         if session_token:
             profiles = list(self.profiles_dir.glob(f"*{session_token}_profile.json"))
         else:
             profiles = list(self.profiles_dir.glob("*.json"))
         
-        # Extract just the name part (without session token)
         profile_names = []
         for p in profiles:
             with open(p, "r", encoding='utf-8') as f:
@@ -1053,336 +649,54 @@ class ProfileManager:
                     continue
         
         return profile_names
-    
-    def _generate_profile_summary(self, data: Dict) -> str:
-        """Generate markdown summary of the profile."""
-        transcript = data.get("transcript", {})
-        favorites = data.get("favorites", {})
-        
-        # Extract just the learning style name
-        learning_style = data.get("learning_style", "")
-        if "Your primary learning style is:" in learning_style:
-            style_match = re.search(r"Your primary learning style is: \*\*(.*?)\*\*", learning_style)
-            if style_match:
-                learning_style = style_match.group(1)
-        
-        markdown = f"""## Student Profile: {data['name']}
-### Basic Information
-- **Age:** {data['age']}
-- **Interests:** {data.get('interests', 'Not specified')}
-- **Learning Style:** {learning_style}
-### Academic Information
-{self._format_transcript(transcript)}
-### Favorites
-- **Movie:** {favorites.get('movie', 'Not specified')}  
-  *Reason:* {favorites.get('movie_reason', 'Not specified')}
-- **TV Show:** {favorites.get('show', 'Not specified')}  
-  *Reason:* {favorites.get('show_reason', 'Not specified')}
-- **Book:** {favorites.get('book', 'Not specified')}  
-  *Reason:* {favorites.get('book_reason', 'Not specified')}
-- **Character:** {favorites.get('character', 'Not specified')}  
-  *Reason:* {favorites.get('character_reason', 'Not specified')}
-### Personal Blog
-{data.get('blog', '_No blog provided_')}
-"""
-        return markdown
-    
-    def _format_transcript(self, transcript: Dict) -> str:
-        """Format transcript data for display."""
-        if not transcript or "course_history" not in transcript:
-            return "_No transcript information available_"
-        
-        display = "#### Course History\n"
-        courses_by_year = defaultdict(list)
-        for course in transcript.get("course_history", []):
-            if course.get("school_year"):
-                courses_by_year[course["school_year"]].append(course)
-        
-        if courses_by_year:
-            for year in sorted(courses_by_year.keys()):
-                display += f"\n**{year}**\n"
-                for course in courses_by_year[year]:
-                    display += f"- {course.get('course_code', '')} {course.get('description', 'Unnamed course')}"
-                    if 'grade' in course and course['grade']:
-                        display += f" (Grade: {course['grade']})"
-                    if 'credits' in course:
-                        display += f" | Credits: {course['credits']}"
-                    display += f" | Category: {course.get('requirement_category', 'N/A')}\n"
-        
-        if 'student_info' in transcript:
-            student = transcript['student_info']
-            display += "\n**Academic Summary**\n"
-            display += f"- Unweighted GPA: {student.get('unweighted_gpa', 'N/A')}\n"
-            display += f"- Weighted GPA: {student.get('weighted_gpa', 'N/A')}\n"
-            display += f"- Total Credits: {student.get('total_credits', 'N/A')}\n"
-        
-        if 'graduation_status' in transcript:
-            status = transcript['graduation_status']
-            display += "\n**Graduation Progress**\n"
-            display += f"- Completion: {status.get('percent_complete', 0)}%\n"
-            display += f"- Credits Required: {status.get('total_required_credits', 0)}\n"
-            display += f"- Credits Completed: {status.get('total_completed_credits', 0)}\n"
-            display += f"- On Track: {'Yes' if status.get('on_track', False) else 'No'}\n"
-        
-        return display
 
-# Initialize profile manager
 profile_manager = ProfileManager()
 
 # ========== AI TEACHING ASSISTANT ==========
 class TeachingAssistant:
     def __init__(self):
         self.context_history = []
-        self.max_context_length = 5  # Keep last 5 exchanges for context
+        self.max_context_length = 5
     
     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
             profile = profile_manager.load_profile(session_token=session_token)
             if not profile:
-                return "Please complete and save your profile first using the previous tabs."
+                return "Please complete and save your profile first."
             
-            # Update context history
             self._update_context(message, history)
             
-            # Extract profile information
-            name = profile.get("name", "there")
-            learning_style = profile.get("learning_style", "")
-            grade_level = profile.get("transcript", {}).get("student_info", {}).get("current_grade", "unknown")
-            gpa = profile.get("transcript", {}).get("student_info", {})
-            interests = profile.get("interests", "")
-            courses = profile.get("transcript", {}).get("course_history", [])
-            favorites = profile.get("favorites", {})
-            
-            # Process message with context
-            response = await self._process_message(message, profile)
+            # Focus on GPA if mentioned
+            if "gpa" in message.lower():
+                gpa = profile.get("transcript", {}).get("student_info", {}).get("gpa", "unknown")
+                return f"Your GPA is {gpa}. Would you like advice on improving it?"
             
-            # Add follow-up suggestions
-            if "study" in message.lower() or "learn" in message.lower():
-                response += "\n\nWould you like me to suggest a study schedule based on your courses?"
-            elif "course" in message.lower() or "class" in message.lower():
-                response += "\n\nWould you like help finding resources for any of these courses?"
-            
-            return response
+            # Generic response otherwise
+            return "I'm your learning assistant. Ask me about your GPA, courses, or study tips."
         
         except Exception as e:
             logging.error(f"Error generating response: {str(e)}")
-            return "I encountered an error processing your request. Please try again."
+            return "I encountered an error. Please try again."
     
     def _update_context(self, message: str, history: List[List[Union[str, None]]]) -> None:
-        """Maintain conversation context."""
         self.context_history.append({"role": "user", "content": message})
         if history:
             for h in history[-self.max_context_length:]:
-                if h[0]:  # User message
+                if h[0]:
                     self.context_history.append({"role": "user", "content": h[0]})
-                if h[1]:  # Assistant message
+                if h[1]:
                     self.context_history.append({"role": "assistant", "content": h[1]})
         
-        # Trim to maintain max context length
         self.context_history = self.context_history[-(self.max_context_length*2):]
-    
-    async def _process_message(self, message: str, profile: Dict) -> str:
-        """Process user message with profile context."""
-        message_lower = message.lower()
-        
-        # Greetings
-        if any(greet in message_lower for greet in ["hi", "hello", "hey", "greetings"]):
-            return f"Hello {profile.get('name', 'there')}! How can I help you with your learning today?"
-        
-        # Study help
-        study_words = ["study", "learn", "prepare", "exam", "test", "homework"]
-        if any(word in message_lower for word in study_words):
-            return self._generate_study_advice(profile)
-        
-        # Grade help
-        grade_words = ["grade", "gpa", "score", "marks", "results"]
-        if any(word in message_lower for word in grade_words):
-            return self._generate_grade_advice(profile)
-        
-        # Interest help
-        interest_words = ["interest", "hobby", "passion", "extracurricular"]
-        if any(word in message_lower for word in interest_words):
-            return self._generate_interest_advice(profile)
-        
-        # Course help
-        course_words = ["courses", "classes", "transcript", "schedule", "subject"]
-        if any(word in message_lower for word in course_words):
-            return self._generate_course_advice(profile)
-        
-        # Favorites
-        favorite_words = ["movie", "show", "book", "character", "favorite"]
-        if any(word in message_lower for word in favorite_words):
-            return self._generate_favorites_response(profile)
-        
-        # General help
-        if "help" in message_lower:
-            return self._generate_help_response()
-        
-        # Default response
-        return ("I'm your personalized teaching assistant. I can help with study tips, "
-                "grade information, course advice, and more. Try asking about how to "
-                "study effectively or about your course history.")
-    
-    def _generate_study_advice(self, profile: Dict) -> str:
-        """Generate study advice based on learning style."""
-        learning_style = profile.get("learning_style", "")
-        response = ""
-        
-        if "Visual" in learning_style:
-            response = ("Based on your visual learning style, I recommend:\n"
-                       "- Creating colorful mind maps or diagrams\n"
-                       "- Using highlighters to color-code your notes\n"
-                       "- Watching educational videos on the topics\n"
-                       "- Creating flashcards with images\n\n")
-        elif "Auditory" in learning_style:
-            response = ("Based on your auditory learning style, I recommend:\n"
-                       "- Recording your notes and listening to them\n"
-                       "- Participating in study groups to discuss concepts\n"
-                       "- Explaining the material out loud to yourself\n"
-                       "- Finding podcasts or audio lectures on the topics\n\n")
-        elif "Reading/Writing" in learning_style:
-            response = ("Based on your reading/writing learning style, I recommend:\n"
-                       "- Writing detailed summaries in your own words\n"
-                       "- Creating organized outlines of the material\n"
-                       "- Reading additional textbooks or articles\n"
-                       "- Rewriting your notes to reinforce learning\n\n")
-        elif "Kinesthetic" in learning_style:
-            response = ("Based on your kinesthetic learning style, I recommend:\n"
-                       "- Creating physical models or demonstrations\n"
-                       "- Using hands-on activities to learn concepts\n"
-                       "- Taking frequent movement breaks while studying\n"
-                       "- Associating information with physical actions\n\n")
-        else:
-            response = ("Here are some general study tips:\n"
-                       "- Use the Pomodoro technique (25 min study, 5 min break)\n"
-                       "- Space out your study sessions over time\n"
-                       "- Test yourself with practice questions\n"
-                       "- Teach the material to someone else\n\n")
-        
-        # Add time management advice
-        response += ("**Time Management Tips**:\n"
-                    "- Create a study schedule and stick to it\n"
-                    "- Prioritize difficult subjects when you're most alert\n"
-                    "- Break large tasks into smaller, manageable chunks\n"
-                    "- Set specific goals for each study session")
-        
-        return response
-    
-    def _generate_grade_advice(self, profile: Dict) -> str:
-        """Generate response about grades and GPA."""
-        gpa = profile.get("transcript", {}).get("student_info", {})
-        courses = profile.get("transcript", {}).get("course_history", [])
-        
-        response = (f"Your GPA information:\n"
-                   f"- Unweighted: {gpa.get('unweighted_gpa', 'N/A')}\n"
-                   f"- Weighted: {gpa.get('weighted_gpa', 'N/A')}\n\n")
-        
-        # Identify any failing grades
-        weak_subjects = []
-        for course in courses:
-            if course.get('grade', '').upper() in ['D', 'F']:
-                weak_subjects.append(f"{course.get('course_code', '')} {course.get('description', 'Unknown course')}")
-        
-        if weak_subjects:
-            response += ("**Areas for Improvement**:\n"
-                        f"You might want to focus on these subjects: {', '.join(weak_subjects)}\n\n")
-        
-        response += ("**Grade Improvement Strategies**:\n"
-                    "- Meet with your teachers to discuss your performance\n"
-                    "- Identify specific areas where you lost points\n"
-                    "- Create a targeted study plan for weak areas\n"
-                    "- Practice with past exams or sample questions")
-        
-        return response
-    
-    def _generate_interest_advice(self, profile: Dict) -> str:
-        """Generate response based on student interests."""
-        interests = profile.get("interests", "")
-        response = f"I see you're interested in: {interests}\n\n"
-        
-        response += ("**Suggestions**:\n"
-                    "- Look for clubs or extracurricular activities related to these interests\n"
-                    "- Explore career paths that align with these interests\n"
-                    "- Find online communities or forums about these topics\n"
-                    "- Consider projects or independent study in these areas")
-        
-        return response
-    
-    def _generate_course_advice(self, profile: Dict) -> str:
-        """Generate response about courses."""
-        courses = profile.get("transcript", {}).get("course_history", [])
-        grade_level = profile.get("transcript", {}).get("student_info", {}).get("current_grade", "unknown")
-        
-        response = "Here's a summary of your courses by year:\n"
-        courses_by_year = defaultdict(list)
-        for course in courses:
-            if course.get("school_year"):
-                courses_by_year[course["school_year"]].append(course)
-        
-        for year in sorted(courses_by_year.keys()):
-            response += f"\n**{year}**:\n"
-            for course in courses_by_year[year]:
-                response += f"- {course.get('course_code', '')} {course.get('description', 'Unnamed course')}"
-                if 'grade' in course:
-                    response += f" (Grade: {course['grade']})"
-                response += "\n"
-        
-        response += f"\nAs a grade {grade_level} student, you might want to:\n"
-        if grade_level in ["9", "10"]:
-            response += ("- Focus on building strong foundational skills\n"
-                        "- Explore different subjects to find your interests\n"
-                        "- Start thinking about college/career requirements")
-        elif grade_level in ["11", "12"]:
-            response += ("- Focus on courses relevant to your college/career goals\n"
-                        "- Consider taking AP or advanced courses if available\n"
-                        "- Ensure you're meeting graduation requirements")
-        
-        return response
-    
-    def _generate_favorites_response(self, profile: Dict) -> str:
-        """Generate response about favorite items."""
-        favorites = profile.get("favorites", {})
-        response = "I see you enjoy:\n"
-        
-        if favorites.get('movie'):
-            response += f"- Movie: {favorites['movie']} ({favorites.get('movie_reason', 'no reason provided')})\n"
-        if favorites.get('show'):
-            response += f"- TV Show: {favorites['show']} ({favorites.get('show_reason', 'no reason provided')})\n"
-        if favorites.get('book'):
-            response += f"- Book: {favorites['book']} ({favorites.get('book_reason', 'no reason provided')})\n"
-        if favorites.get('character'):
-            response += f"- Character: {favorites['character']} ({favorites.get('character_reason', 'no reason provided')})\n"
-        
-        response += "\nThese preferences suggest you might enjoy:\n"
-        response += "- Similar books/movies in the same genre\n"
-        response += "- Creative projects related to these stories\n"
-        response += "- Analyzing themes or characters in your schoolwork"
-        
-        return response
-    
-    def _generate_help_response(self) -> str:
-        """Generate help response with available commands."""
-        return ("""I can help with:
-- **Study tips**: "How should I study for math?"
-- **Grade information**: "What's my GPA?"
-- **Course advice**: "Show me my course history"
-- **Interest suggestions**: "What clubs match my interests?"
-- **General advice**: "How can I improve my grades?"
-Try asking about any of these topics!""")
 
-# Initialize teaching assistant
 teaching_assistant = TeachingAssistant()
 
 # ========== GRADIO INTERFACE ==========
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Student Learning Assistant") as app:
-        # Session state
         session_token = gr.State(value=generate_session_token())
         profile_manager.set_session(session_token.value)
         
-        # Track completion status for each tab
         tab_completed = gr.State({
             0: False,  # Transcript Upload
             1: False,  # Learning Style Quiz
@@ -1391,7 +705,7 @@ def create_interface():
             4: False   # AI Assistant
         })
         
-        # Custom CSS with dark mode support
+        # Custom CSS
         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; }
@@ -1404,7 +718,6 @@ def create_interface():
         .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; }
@@ -1414,7 +727,7 @@ def create_interface():
         .dark .chatbot .user, .dark .chatbot .assistant { color: #eee !important; }
         """
         
-        # Header with dark mode toggle
+        # Header
         with gr.Row():
             with gr.Column(scale=4):
                 gr.Markdown("""
@@ -1440,7 +753,7 @@ def create_interface():
 
         nav_message = gr.HTML(visible=False)
 
-        # Main tabs container - Now VISIBLE
+        # Main tabs
         with gr.Tabs(visible=True) as tabs:
             # ===== TAB 1: TRANSCRIPT UPLOAD =====
             with gr.Tab("Transcript", id=0):
@@ -1459,59 +772,25 @@ def create_interface():
                     with gr.Column(scale=2):
                         transcript_output = gr.Textbox(
                             label="Analysis Results", 
-                            lines=20,
+                            lines=5,
                             interactive=False
                         )
                         transcript_data = gr.State()
 
-                def process_transcript(file_obj, current_tab_status):
-                    try:
-                        if not file_obj:
-                            raise ValueError("Please upload a transcript file first.")
-                            
-                        output_text, data = parse_transcript(file_obj)
-                        
-                        if "Error" in output_text:
-                            return (
-                                output_text,
-                                None,
-                                current_tab_status,
-                                gr.update(),
-                                gr.update(),
-                                gr.update(visible=True, value=f"<div class='error-message'>{output_text}</div>"),
-                                gr.update(visible=False)
-                            )
-                        
-                        new_status = current_tab_status.copy()
-                        new_status[0] = True
-                        return (
-                            output_text, 
-                            data, 
-                            new_status,
-                            gr.update(elem_classes="completed-tab"),
-                            gr.update(interactive=True),
-                            gr.update(visible=False),
-                            gr.update(visible=False)
-                        )
-                        
-                    except Exception as e:
-                        error_msg = f"Error processing transcript: {str(e)}"
-                        if "PDF" in str(e):
-                            error_msg += "\n\nTIPS:\n- Try converting to image (screenshot)\n- Ensure text is selectable in PDF\n- Try a different PDF reader"
-                        return (
-                            error_msg,
-                            None,
-                            current_tab_status,
-                            gr.update(),
-                            gr.update(),
-                            gr.update(visible=True, value=f"<div class='error-message'>{error_msg}</div>"),
-                            gr.update(visible=False)
-                        )
-                
                 upload_btn.click(
-                    process_transcript,
+                    fn=parse_transcript,
                     inputs=[file_input, tab_completed],
-                    outputs=[transcript_output, transcript_data, tab_completed, step1, step2, file_error, nav_message]
+                    outputs=[transcript_output, transcript_data]
+                ).then(
+                    fn=lambda: {0: True},
+                    inputs=None,
+                    outputs=tab_completed
+                ).then(
+                    fn=lambda: gr.update(elem_classes="completed-tab"),
+                    outputs=step1
+                ).then(
+                    fn=lambda: gr.update(interactive=True),
+                    outputs=step2
                 )
 
             # ===== TAB 2: LEARNING STYLE QUIZ =====
@@ -1542,7 +821,6 @@ def create_interface():
                         elem_classes="quiz-results"
                     )
 
-                # Update progress bar as questions are answered
                 for component in quiz_components:
                     component.change(
                         fn=lambda *answers: {
@@ -1554,38 +832,23 @@ def create_interface():
                         outputs=progress
                     )
                 
-                def submit_quiz_and_update(*args):
-                    current_tab_status = args[0]
-                    answers = args[1:]
-                    
-                    try:
-                        result = learning_style_quiz.evaluate_quiz(*answers)
-                        new_status = current_tab_status.copy()
-                        new_status[1] = True
-                        return (
-                            result,
-                            gr.update(visible=True),
-                            new_status,
-                            gr.update(elem_classes="completed-tab"),
-                            gr.update(interactive=True),
-                            gr.update(value="<div class='alert-box'>Quiz submitted successfully!</div>", visible=True),
-                            gr.update(visible=False)
-                        )
-                    except Exception as e:
-                        return (
-                            f"Error evaluating quiz: {str(e)}",
-                            gr.update(visible=True),
-                            current_tab_status,
-                            gr.update(),
-                            gr.update(),
-                            gr.update(value=f"<div class='error-message'>Error: {str(e)}</div>", visible=True),
-                            gr.update(visible=False)
-                        )
-                
                 quiz_submit.click(
-                    fn=submit_quiz_and_update,
-                    inputs=[tab_completed] + quiz_components,
-                    outputs=[learning_output, learning_output, tab_completed, step2, step3, quiz_alert, nav_message]
+                    fn=lambda *answers: learning_style_quiz.evaluate_quiz(*answers),
+                    inputs=quiz_components,
+                    outputs=learning_output
+                ).then(
+                    fn=lambda: gr.update(visible=True),
+                    outputs=learning_output
+                ).then(
+                    fn=lambda: {1: True},
+                    inputs=None,
+                    outputs=tab_completed
+                ).then(
+                    fn=lambda: gr.update(elem_classes="completed-tab"),
+                    outputs=step2
+                ).then(
+                    fn=lambda: gr.update(interactive=True),
+                    outputs=step3
                 )
                 
                 quiz_clear.click(
@@ -1624,42 +887,22 @@ def create_interface():
                             character = gr.Textbox(label="Favorite Character (from any story)")
                             character_reason = gr.Textbox(label="Why do you like them?", lines=2)
                         
-                        # Added blog section
                         with gr.Accordion("Personal Blog (Optional)", open=False):
                             blog = gr.Textbox(
                                 label="Share your thoughts",
-                                placeholder="Write something about yourself, your goals, or anything you'd like to share...",
+                                placeholder="Write something about yourself...",
                                 lines=5
                             )
                 
-                def save_personal_info(name, age, interests, current_tab_status):
-                    try:
-                        name = validate_name(name)
-                        age = validate_age(age)
-                        interests = sanitize_input(interests)
-                        
-                        new_status = current_tab_status.copy()
-                        new_status[2] = True
-                        return (
-                            new_status,
-                            gr.update(elem_classes="completed-tab"),
-                            gr.update(interactive=True),
-                            gr.update(value="<div class='alert-box'>Information saved!</div>", visible=True),
-                            gr.update(visible=False)
-                        )
-                    except Exception as e:
-                        return (
-                            current_tab_status,
-                            gr.update(),
-                            gr.update(),
-                            gr.update(visible=False),
-                            gr.update(visible=True, value=f"<div class='error-message'>Error: {str(e)}</div>")
-                        )
-                
                 save_personal_btn.click(
-                    fn=save_personal_info,
+                    fn=lambda n, a, i, ts: (
+                        {2: True},
+                        gr.update(elem_classes="completed-tab"),
+                        gr.update(interactive=True),
+                        gr.update(value="<div class='alert-box'>Information saved!</div>", visible=True)
+                    ),
                     inputs=[name, age, interests, tab_completed],
-                    outputs=[tab_completed, step3, step4, save_confirmation, nav_message]
+                    outputs=[tab_completed, step3, step4, save_confirmation]
                 )
 
             # ===== TAB 4: SAVE & REVIEW =====
@@ -1686,69 +929,24 @@ def create_interface():
                             label="Profile Summary"
                         )
 
-                def save_profile_and_update(name, age, interests, transcript_data, learning_style, 
-                                         movie, movie_reason, show, show_reason,
-                                         book, book_reason, character, character_reason, blog,
-                                         current_tab_status):
-                    try:
-                        summary = profile_manager.save_profile(
-                            name, age, interests, transcript_data, learning_style,
-                            movie, movie_reason, show, show_reason,
-                            book, book_reason, character, character_reason, blog
-                        )
-                        new_status = current_tab_status.copy()
-                        new_status[3] = True
-                        return (
-                            summary,
-                            new_status,
-                            gr.update(elem_classes="completed-tab"),
-                            gr.update(interactive=True),
-                            gr.update(visible=False)
-                        )
-                    except Exception as e:
-                        return (
-                            f"Error saving profile: {str(e)}",
-                            current_tab_status,
-                            gr.update(),
-                            gr.update(),
-                            gr.update(visible=True, value=f"<div class='error-message'>Error: {str(e)}</div>")
-                        )
-                
                 save_btn.click(
-                    fn=save_profile_and_update,
+                    fn=profile_manager.save_profile,
                     inputs=[
                         name, age, interests, transcript_data, learning_output,
                         movie, movie_reason, show, show_reason,
-                        book, book_reason, character, character_reason, blog,
-                        tab_completed
+                        book, book_reason, character, character_reason, blog
                     ],
-                    outputs=[output_summary, tab_completed, step4, step5, nav_message]
+                    outputs=output_summary
                 ).then(
-                    fn=lambda: profile_manager.list_profiles(session_token.value),
-                    outputs=load_profile_dropdown
+                    fn=lambda: {3: True},
+                    inputs=None,
+                    outputs=tab_completed
                 ).then(
-                    fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
-                    outputs=load_btn
+                    fn=lambda: gr.update(elem_classes="completed-tab"),
+                    outputs=step4
                 ).then(
-                    fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
-                    outputs=delete_btn
-                )
-                
-                def delete_profile(name, session_token):
-                    if not name:
-                        raise gr.Error("Please select a profile to delete")
-                    try:
-                        profile_path = profile_manager.get_profile_path(name)
-                        if profile_path.exists():
-                            profile_path.unlink()
-                        return "Profile deleted successfully", ""
-                    except Exception as e:
-                        raise gr.Error(f"Error deleting profile: {str(e)}")
-                
-                delete_btn.click(
-                    fn=delete_profile,
-                    inputs=[load_profile_dropdown, session_token],
-                    outputs=[output_summary, load_profile_dropdown]
+                    fn=lambda: gr.update(interactive=True),
+                    outputs=step5
                 ).then(
                     fn=lambda: profile_manager.list_profiles(session_token.value),
                     outputs=load_profile_dropdown
@@ -1759,23 +957,12 @@ def create_interface():
                     fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
                     outputs=delete_btn
                 )
-                
-                clear_btn.click(
-                    fn=lambda: [gr.update(value="") for _ in range(12)],
-                    outputs=[
-                        name, age, interests, 
-                        movie, movie_reason, show, show_reason,
-                        book, book_reason, character, character_reason,
-                        output_summary
-                    ]
-                )
 
             # ===== TAB 5: AI ASSISTANT =====
             with gr.Tab("AI Assistant", id=4):
                 gr.Markdown("## Your Personalized Learning Assistant")
                 gr.Markdown("Ask me anything about studying, your courses, grades, or learning strategies.")
                 
-                # Create a wrapper function that properly awaits the async function
                 async def chat_wrapper(message: str, history: List[List[str]]):
                     response = await teaching_assistant.generate_response(
                         message, 
@@ -1787,11 +974,10 @@ def create_interface():
                 chatbot = gr.ChatInterface(
                     fn=chat_wrapper,
                     examples=[
-                        "How should I study for my next math test?",
-                        "What's my current GPA?",
-                        "Show me my course history",
-                        "How can I improve my grades in science?",
-                        "What study methods match my learning style?"
+                        "What's my GPA?",
+                        "How should I study for math?",
+                        "What courses am I taking?",
+                        "Study tips for my learning style"
                     ],
                     title=""
                 )
@@ -1800,11 +986,9 @@ def create_interface():
         def navigate_to_tab(tab_index: int, tab_completed_status):
             current_tab = tabs.selected
             
-            # Allow backward navigation
             if tab_index <= current_tab:
                 return gr.Tabs(selected=tab_index), gr.update(visible=False)
             
-            # Check if current tab is completed
             if not tab_completed_status.get(current_tab, False):
                 messages = {
                     0: "Please complete the transcript analysis first.",
@@ -1822,7 +1006,6 @@ def create_interface():
             
             return gr.Tabs(selected=tab_index), gr.update(visible=False)
         
-        # Connect navigation buttons
         step1.click(
             lambda idx, status: navigate_to_tab(idx, status),
             inputs=[gr.State(0), tab_completed],
@@ -1864,7 +1047,6 @@ def create_interface():
     
     return app
 
-# Create and launch the interface
 app = create_interface()
 
 if __name__ == "__main__":