Update app.py

app.py

@@ -252,158 +252,84 @@ class LearningStyleQuiz:
 # Initialize learning style quiz
 learning_style_quiz = LearningStyleQuiz()
 
-# ========== MODEL LOADER ==========
-class ModelLoader:
-    def __init__(self):
-        self.model = None
-        self.tokenizer = None
-        self.loaded = False
-        self.loading = False
-        self.error = None
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.load_attempts = 0
-        self.max_retries = 3
-    
-    def load_model(self, progress: gr.Progress = None) -> Tuple[Optional[AutoModelForCausalLM], Optional[AutoTokenizer]]:
-        if self.loaded:
-            return self.model, self.tokenizer
-            
-        if self.loading:
-            while self.loading and self.load_attempts < self.max_retries:
-                time.sleep(0.5)
-            return self.model, self.tokenizer
-            
-        self.loading = True
-        self.load_attempts += 1
-        
-        try:
-            if progress:
-                progress(0.1, desc="Initializing model environment...")
-            
-            if self.device == "cuda":
-                torch.cuda.empty_cache()
-                torch.cuda.reset_peak_memory_stats()
-            
-            if progress:
-                progress(0.2, desc="Loading tokenizer...")
-                
-            tokenizer = None
-            for attempt in range(3):
-                try:
-                    tokenizer = AutoTokenizer.from_pretrained(
-                        MODEL_NAME,
-                        trust_remote_code=True,
-                        use_fast=True
-                    )
-                    break
-                except Exception as e:
-                    if attempt == 2:
-                        raise
-                    logger.warning(f"Tokenizer loading attempt {attempt + 1} failed: {str(e)}")
-                    time.sleep(2 ** attempt)
-            
-            if progress:
-                progress(0.5, desc="Loading model (this may take a few minutes)...")
-                
-            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"
-            }
-
-            if torch.cuda.device_count() > 1:
-                model_kwargs["max_memory"] = {i: "20GiB" for i in range(torch.cuda.device_count())}
-            
-            model = None
-            for attempt in range(3):
-                try:
-                    model = AutoModelForCausalLM.from_pretrained(
-                        MODEL_NAME,
-                        **model_kwargs
-                    )
-                    break
-                except torch.cuda.OutOfMemoryError:
-                    logger.warning("CUDA OOM encountered, trying CPU offloading")
-                    model_kwargs["device_map"] = None
-                    model = AutoModelForCausalLM.from_pretrained(
-                        MODEL_NAME,
-                        **model_kwargs
-                    ).to('cpu')
-                    self.device = 'cpu'
-                    break
-                except Exception as e:
-                    if attempt == 2:
-                        raise
-                    logger.warning(f"Model loading attempt {attempt + 1} failed: {str(e)}")
-                    time.sleep(2 ** attempt)
-            
-            if progress:
-                progress(0.8, desc="Verifying model...")
-            test_input = tokenizer("Test", return_tensors="pt").to(self.device)
-            with torch.no_grad():
-                _ = model.generate(**test_input, max_new_tokens=1)
-            
-            self.model = model.eval()
-            self.tokenizer = tokenizer
-            self.loaded = True
-            logger.info("Model loaded successfully")
-            
-            return model, tokenizer
-            
-        except Exception as e:
-            self.error = f"Model loading failed after {self.load_attempts} attempts: {str(e)}"
-            logger.error(self.error)
-            if self.load_attempts < self.max_retries:
-                logger.info(f"Retrying model loading ({self.load_attempts}/{self.max_retries})")
-                time.sleep(5)
-                return self.load_model(progress)
-            return None, None
-        finally:
-            self.loading = False
-
-# Initialize model loader
-model_loader = ModelLoader()
-
-@lru_cache(maxsize=1)
-def get_model_and_tokenizer():
-    return model_loader.load_model()
-
 # ========== TRANSCRIPT PARSER ==========
 class MiamiDadeTranscriptParser:
     def __init__(self):
-        self.student_info_pattern = re.compile(
-            r"(\d{7}) - (.*?)\s*\|\s*Current Grade:\s*(\d+)\s*\|\s*YOG\s*(\d{4})"
-            r"\s*\|\s*Weighted GPA\s*([\d.]+)\s*\|\s*Comm Serv Date\s*(\d{2}/\d{2}/\d{4})"
-            r"\s*\|\s*Total Credits Earned\s*([\d.]+)"
-        )
-        
-        self.requirement_pattern = re.compile(
-            r"([A-Z]-[A-Za-z ]+)\s*\|\s*([^|]+)\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([^|]+)%"
-        )
+        # Patterns for both transcript formats
+        self.format1_patterns = {
+            'student_info': re.compile(
+                r"(\d{7}) - (.*?)\s*\|\s*Current Grade:\s*(\d+)\s*\|\s*YOG\s*(\d{4})"
+                r"\s*\|\s*Weighted GPA\s*([\d.]+)\s*\|\s*Comm Serv Date\s*(\d{2}/\d{2}/\d{4})"
+                r"\s*\|\s*Total Credits Earned\s*([\d.]+)"
+            ),
+            'requirement': re.compile(
+                r"([A-Z]-[A-Za-z ]+)\s*\|\s*([^|]+)\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([^|]+)%"
+            ),
+            'course': re.compile(
+                r"([A-Z]-[A-Za-z ]+)\s*\|\s*(\d{4}-\d{4})\s*\|\s*(\d{2})\s*\|\s*([A-Z0-9]+)\s*\|\s*([^|]+)\|"
+                r"\s*([A-Z0-9])\s*\|\s*(\d+)\s*\|\s*([A-Z])\s*\|\s*([A-Z])\s*\|\s*([\d.]+|inProgress)"
+            )
+        }
         
-        self.course_pattern = re.compile(
-            r"([A-Z]-[A-Za-z ]+)\s*\|\s*(\d{4}-\d{4})\s*\|\s*(\d{2})\s*\|\s*([A-Z0-9]+)\s*\|\s*([^|]+)\|"
-            r"\s*([A-Z0-9])\s*\|\s*(\d+)\s*\|\s*([A-Z])\s*\|\s*([A-Z])\s*\|\s*([\d.]+|inProgress)"
-        )
+        self.format2_patterns = {
+            'student_info': re.compile(
+                r"LEGAL NAME:\s*([A-Z]+,\s*[A-Z]+).*?"
+                r"GRADE LEVEL:\s*(\d+).*?"
+                r"FL STUDENT ID:\s*(\w+).*?"
+                r"CURRENT SCHOOL:\s*(\d+\s+[\w\s]+?)\s*\(",
+                re.DOTALL
+            ),
+            'gpa': re.compile(
+                r"DISTRICT:\s*([\d.]+).*?STATE:\s*([\d.]+)",
+                re.DOTALL
+            ),
+            'credits': re.compile(
+                r"\*\s+([A-Z\s]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s*\*",
+                re.DOTALL
+            ),
+            'course': re.compile(
+                r"(\d)\s+(\w+)\s+([\w\s]+?)\s+([A-Z]{2})\s+([A-Z])\s+([A-Z])\s+([A-Z])\s+([\d.]+)\s+([\d.]+)",
+                re.DOTALL
+            ),
+            'assessment': re.compile(
+                r"ENGLISH/LANGUAGE ARTS:\s*(\d{2}/\d{4})|"
+                r"ALGEBRA I ASSESSMENT REQUIREMENT MET:\s*(YES|NO)|"
+                r"BIOLOGY ASSESSMENT PASSED|"
+                r"DISTRICT COMM/VOL SERVICE RQMT MET:\s*(YES).*?HRS:\s*(\d+)",
+                re.DOTALL
+            )
+        }
 
     def parse_transcript(self, file_path: str) -> Dict:
-        """Parse Miami-Dade County transcript PDF"""
+        """Parse Miami-Dade transcript PDF, automatically detecting format"""
         with pdfplumber.open(file_path) as pdf:
             text = "\n".join(page.extract_text() for page in pdf.pages)
             
-            parsed_data = {
-                'student_info': self._parse_student_info(text),
-                'requirements': self._parse_requirements(text),
-                'course_history': self._parse_courses(text)
-            }
+            # Clean up text
+            text = re.sub(r'\s+', ' ', text)
+            text = re.sub(r'(?<=\d)\s+(?=\d)', '', text)
             
-            return parsed_data
+            # Detect format
+            if "GRADUATION PROGRESS SUMMARY" in text:
+                return self._parse_format1(text)
+            elif "CUMULATIVE SUMMARY" in text:
+                return self._parse_format2(text)
+            else:
+                raise ValueError("Unrecognized transcript format")
+
+    def _parse_format1(self, text: str) -> Dict:
+        """Parse the first transcript format"""
+        parsed_data = {
+            'student_info': self._parse_format1_student_info(text),
+            'requirements': self._parse_format1_requirements(text),
+            'course_history': self._parse_format1_courses(text),
+            'format': 'progress_summary'
+        }
+        return parsed_data
 
-    def _parse_student_info(self, text: str) -> Dict:
-        """Extract student information"""
-        match = self.student_info_pattern.search(text)
+    def _parse_format1_student_info(self, text: str) -> Dict:
+        """Extract student information from format 1"""
+        match = self.format1_patterns['student_info'].search(text)
         if not match:
             return {}
             
@@ -418,10 +344,10 @@ class MiamiDadeTranscriptParser:
             'district': 'Miami-Dade'
         }
 
-    def _parse_requirements(self, text: str) -> Dict:
-        """Parse graduation requirements section"""
+    def _parse_format1_requirements(self, text: str) -> Dict:
+        """Parse graduation requirements section from format 1"""
         requirements = {}
-        for match in self.requirement_pattern.finditer(text):
+        for match in self.format1_patterns['requirement'].finditer(text):
             requirements[match.group(1).strip()] = {
                 'description': match.group(2).strip(),
                 'required': float(match.group(3)),
@@ -431,10 +357,10 @@ class MiamiDadeTranscriptParser:
             }
         return requirements
 
-    def _parse_courses(self, text: str) -> List[Dict]:
-        """Parse course history section"""
+    def _parse_format1_courses(self, text: str) -> List[Dict]:
+        """Parse course history section from format 1"""
         courses = []
-        for match in self.course_pattern.finditer(text):
+        for match in self.format1_patterns['course'].finditer(text):
             courses.append({
                 'requirement': match.group(1).strip(),
                 'school_year': match.group(2),
@@ -449,6 +375,122 @@ class MiamiDadeTranscriptParser:
             })
         return courses
 
+    def _parse_format2(self, text: str) -> Dict:
+        """Parse the second transcript format"""
+        parsed_data = {
+            'student_info': self._parse_format2_student_info(text),
+            'academic_summary': self._parse_format2_academic_summary(text),
+            'course_history': self._parse_format2_courses(text),
+            'assessments': self._parse_format2_assessments(text),
+            'format': 'cumulative_summary'
+        }
+        return parsed_data
+
+    def _parse_format2_student_info(self, text: str) -> Dict:
+        """Extract student information from format 2"""
+        match = self.format2_patterns['student_info'].search(text)
+        if not match:
+            return {}
+            
+        return {
+            'name': match.group(1).replace(',', ' ').strip(),
+            'grade': match.group(2),
+            'student_id': match.group(3),
+            'school': match.group(4).strip(),
+            'birth_date': self._extract_birth_date(text),
+            'ethnicity': self._extract_ethnicity(text)
+        }
+
+    def _extract_birth_date(self, text: str) -> Optional[str]:
+        """Extract birth date from transcript"""
+        birth_match = re.search(r"BIRTH DATE:\s*(\d{2}/\d{2}/\d{4})", text)
+        return birth_match.group(1) if birth_match else None
+
+    def _extract_ethnicity(self, text: str) -> Optional[str]:
+        """Extract ethnicity information"""
+        eth_match = re.search(r"ETHNICITY:\s*([^\n]+)", text)
+        return eth_match.group(1).strip() if eth_match else None
+
+    def _parse_format2_academic_summary(self, text: str) -> Dict:
+        """Parse academic summary section from format 2"""
+        gpa_match = self.format2_patterns['gpa'].search(text)
+        credits_matches = self.format2_patterns['credits'].finditer(text)
+        
+        summary = {
+            'gpa': {
+                'district': float(gpa_match.group(1)) if gpa_match else None,
+                'state': float(gpa_match.group(2)) if gpa_match else None
+            },
+            'credits': {},
+            'class_rank': self._extract_class_rank(text)
+        }
+        
+        for match in credits_matches:
+            subject = match.group(1).strip()
+            summary['credits'][subject] = {
+                'earned': float(match.group(2)),
+                'required': float(match.group(3)) if match.group(3) else None,
+                'remaining': float(match.group(4)) if match.group(4) else None
+            }
+            
+        return summary
+
+    def _extract_class_rank(self, text: str) -> Dict:
+        """Extract class rank information"""
+        rank_match = re.search(
+            r"\*\s+PERCENTILE:\s*(\d+)\s*\*\s*TOTAL NUMBER IN CLASS:\s*(\d+)",
+            text
+        )
+        return {
+            'percentile': int(rank_match.group(1)) if rank_match else None,
+            'class_size': int(rank_match.group(2)) if rank_match else None
+        }
+
+    def _parse_format2_courses(self, text: str) -> List[Dict]:
+        """Parse course history section from format 2"""
+        courses = []
+        for match in self.format2_patterns['course'].finditer(text):
+            courses.append({
+                'term': match.group(1),
+                'course_code': match.group(2),
+                'course_title': match.group(3).strip(),
+                'subject_area': match.group(4),
+                'grade': match.group(5),
+                'flag': match.group(6),
+                'credit_status': match.group(7),
+                'credit_attempted': float(match.group(8)),
+                'credit_earned': float(match.group(9))
+            })
+        return courses
+
+    def _parse_format2_assessments(self, text: str) -> Dict:
+        """Parse assessment and requirement information from format 2"""
+        matches = self.format2_patterns['assessment'].finditer(text)
+        assessments = {
+            'ela_passed_date': None,
+            'algebra_passed': False,
+            'biology_passed': False,
+            'community_service': {
+                'met': False,
+                'hours': 0
+            }
+        }
+        
+        for match in matches:
+            if match.group(1):  # ELA date
+                assessments['ela_passed_date'] = match.group(1)
+            elif match.group(2):  # Algebra
+                assessments['algebra_passed'] = match.group(2) == "YES"
+            elif "BIOLOGY ASSESSMENT PASSED" in match.group(0):
+                assessments['biology_passed'] = True
+            elif match.group(3):  # Community service
+                assessments['community_service'] = {
+                    'met': True,
+                    'hours': int(match.group(4))
+                }
+                
+        return assessments
+
 # Initialize transcript parser
 transcript_parser = MiamiDadeTranscriptParser()
 
@@ -476,8 +518,12 @@ class AcademicAnalyzer:
         }
         
         try:
-            weighted_gpa = float(parsed_data.get('student_info', {}).get('weighted_gpa', 0))
-            unweighted_gpa = float(parsed_data.get('student_info', {}).get('unweighted_gpa', 0))
+            if parsed_data.get('format') == 'progress_summary':
+                weighted_gpa = float(parsed_data.get('student_info', {}).get('weighted_gpa', 0))
+                unweighted_gpa = float(parsed_data.get('student_info', {}).get('unweighted_gpa', 0))
+            else:
+                weighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('district', 0))
+                unweighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('state', 0))
             
             if weighted_gpa >= 4.5:
                 analysis['rating'] = 'Excellent'
@@ -553,30 +599,59 @@ class AcademicAnalyzer:
         }
         
         try:
-            total_required = sum(
-                float(req.get('required', 0))
-                for req in parsed_data.get('requirements', {}).values() 
-                if req and str(req.get('required', '0')).replace('.','').isdigit()
-            )
-            
-            total_completed = sum(
-                float(req.get('completed', 0))
-                for req in parsed_data.get('requirements', {}).values() 
-                if req and str(req.get('completed', '0')).replace('.','').isdigit()
-            )
-            
-            analysis['completion_percentage'] = (total_completed / total_required) * 100 if total_required > 0 else 0
-            
-            analysis['missing_requirements'] = [
-                {
-                    'code': code,
-                    'description': req.get('description', ''),
-                    'remaining': max(0, float(req.get('required', 0)) - float(req.get('completed', 0))),
-                    'status': req.get('status', '')
-                }
-                for code, req in parsed_data.get('requirements', {}).items()
-                if req and float(req.get('completed', 0)) < float(req.get('required', 0))
-            ]
+            if parsed_data.get('format') == 'progress_summary':
+                # Format 1 analysis
+                total_match = re.search(r'Total\s*\|\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)%', text)
+                if total_match:
+                    analysis['completion_percentage'] = float(total_match.group(4))
+                else:
+                    total_required = sum(
+                        float(req.get('required', 0))
+                        for req in parsed_data.get('requirements', {}).values() 
+                        if req and str(req.get('required', '0')).replace('.','').isdigit()
+                    )
+                    total_completed = sum(
+                        float(req.get('completed', 0))
+                        for req in parsed_data.get('requirements', {}).values() 
+                        if req and str(req.get('completed', '0')).replace('.','').isdigit()
+                    )
+                    analysis['completion_percentage'] = (total_completed / total_required) * 100 if total_required > 0 else 0
+                
+                analysis['missing_requirements'] = [
+                    {
+                        'code': code,
+                        'description': req.get('description', ''),
+                        'remaining': max(0, float(req.get('required', 0)) - float(req.get('completed', 0))),
+                        'status': req.get('status', '')
+                    }
+                    for code, req in parsed_data.get('requirements', {}).items()
+                    if req and float(req.get('completed', 0)) < float(req.get('required', 0))
+                ]
+            else:
+                # Format 2 analysis
+                credits = parsed_data.get('academic_summary', {}).get('credits', {})
+                total_required = sum(
+                    v.get('required', 0) 
+                    for v in credits.values() 
+                    if v and isinstance(v.get('required'), (int, float))
+                )
+                total_earned = sum(
+                    v.get('earned', 0) 
+                    for v in credits.values() 
+                    if v and isinstance(v.get('earned'), (int, float))
+                )
+                analysis['completion_percentage'] = (total_earned / total_required) * 100 if total_required > 0 else 0
+                
+                analysis['missing_requirements'] = [
+                    {
+                        'subject': subject,
+                        'earned': info.get('earned', 0),
+                        'required': info.get('required', 0),
+                        'remaining': max(0, info.get('required', 0) - info.get('earned', 0))
+                    }
+                    for subject, info in credits.items()
+                    if info and info.get('required', 0) > info.get('earned', 0)
+                ]
             
             current_grade = parsed_data.get('student_info', {}).get('grade', '')
             grad_year = parsed_data.get('student_info', {}).get('year_of_graduation', '')
@@ -598,7 +673,7 @@ class AcademicAnalyzer:
                 analysis['on_track'] = False
             
             if current_grade and grad_year:
-                remaining_credits = total_required - total_completed
+                remaining_credits = total_required - total_earned
                 years_remaining = int(grad_year) - datetime.datetime.now().year - int(current_grade)
                 
                 if years_remaining > 0:
@@ -630,23 +705,27 @@ class AcademicAnalyzer:
         }
         
         try:
-            for course in parsed_data.get('course_history', []):
-                course_name = course.get('description', '').upper()
-                if 'AP' in course_name:
+            courses = parsed_data.get('course_history', [])
+            
+            for course in courses:
+                course_title = course.get('description', '') or course.get('course_title', '')
+                course_title = course_title.upper()
+                
+                if 'AP' in course_title or 'ADVANCED PLACEMENT' in course_title:
                     analysis['ap_courses'] += 1
                     analysis['advanced_courses'] += 1
-                elif 'IB' in course_name:
+                elif 'IB' in course_title or 'INTERNATIONAL BACCALAUREATE' in course_title:
                     analysis['ib_courses'] += 1
                     analysis['advanced_courses'] += 1
-                elif 'DE' in course_name or 'DUAL ENROLLMENT' in course_name:
+                elif 'DE' in course_title or 'DUAL ENROLLMENT' in course_title or 'COLLEGE' in course_title:
                     analysis['de_courses'] += 1
                     analysis['advanced_courses'] += 1
-                elif 'HONORS' in course_name:
+                elif 'HONORS' in course_title or course.get('flag', '') == 'H':
                     analysis['honors_courses'] += 1
                     analysis['advanced_courses'] += 1
             
             total_advanced = analysis['advanced_courses']
-            total_courses = len(parsed_data.get('course_history', []))
+            total_courses = len(courses)
             
             if total_courses == 0:
                 return analysis
@@ -701,9 +780,14 @@ class AcademicAnalyzer:
         }
         
         try:
-            weighted_gpa = float(parsed_data.get('student_info', {}).get('weighted_gpa', 0))
+            if parsed_data.get('format') == 'progress_summary':
+                weighted_gpa = float(parsed_data.get('student_info', {}).get('weighted_gpa', 0))
+                service_hours = int(parsed_data.get('student_info', {}).get('community_service_hours', 0))
+            else:
+                weighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('district', 0))
+                service_hours = int(parsed_data.get('assessments', {}).get('community_service', {}).get('hours', 0))
+            
             rigor_analysis = self.analyze_course_rigor(parsed_data)
-            service_hours = int(parsed_data.get('student_info', {}).get('community_service_hours', 0))
             
             if weighted_gpa >= 4.3 and rigor_analysis['advanced_courses'] >= 8 and service_hours >= 100:
                 recommendations['reach'].extend([
@@ -799,7 +883,8 @@ class AcademicAnalyzer:
         try:
             current_courses = [
                 course for course in parsed_data.get('course_history', [])
-                if course.get('status', '').lower() == 'in progress'
+                if course.get('status', '').lower() == 'in progress' or 
+                (isinstance(course.get('credit_earned'), float) and course['credit_earned'] == 0)
             ]
             
             days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
@@ -839,8 +924,9 @@ class AcademicAnalyzer:
             for i, course in enumerate(current_courses):
                 day_index = i % 5
                 day = days[day_index]
+                course_name = course.get('description') or course.get('course_title', 'Course')
                 plan['weekly_schedule'][day].append({
-                    'course': course.get('description', 'Course'),
+                    'course': course_name,
                     'duration': '45-60 minutes',
                     'activities': [
                         "Review notes",
@@ -889,12 +975,16 @@ class DataVisualizer:
     
     def create_gpa_visualization(self, parsed_data: Dict):
         try:
+            if parsed_data.get('format') == 'progress_summary':
+                weighted_gpa = float(parsed_data.get('student_info', {}).get('weighted_gpa', 0))
+                unweighted_gpa = float(parsed_data.get('student_info', {}).get('unweighted_gpa', 0))
+            else:
+                weighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('district', 0))
+                unweighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('state', 0))
+            
             gpa_data = {
                 "Type": ["Weighted GPA", "Unweighted GPA"],
-                "Value": [
-                    float(parsed_data.get('student_info', {}).get('weighted_gpa', 0)),
-                    float(parsed_data.get('student_info', {}).get('unweighted_gpa', 0))
-                ],
+                "Value": [weighted_gpa, unweighted_gpa],
                 "Color": [self.color_palette['gpa_weighted'], self.color_palette['gpa_unweighted']]
             }
             
@@ -941,18 +1031,33 @@ class DataVisualizer:
     
     def create_requirements_visualization(self, parsed_data: Dict):
         try:
-            req_data = []
-            for code, req in parsed_data.get('requirements', {}).items():
-                if req and req.get('percent_complete'):
-                    completion = float(req['percent_complete'])
-                    req_data.append({
-                        "Requirement": f"{code}: {req.get('description', '')[:30]}...",
-                        "Completion (%)": completion,
-                        "Status": "Complete" if completion >= 100 else "In Progress" if completion > 0 else "Not Started",
-                        "Required": req.get('required', 0),
-                        "Completed": req.get('completed', 0),
-                        "Remaining": max(0, float(req.get('required', 0)) - float(req.get('completed', 0)))
-                    })
+            if parsed_data.get('format') == 'progress_summary':
+                req_data = []
+                for code, req in parsed_data.get('requirements', {}).items():
+                    if req and req.get('percent_complete'):
+                        completion = float(req['percent_complete'])
+                        req_data.append({
+                            "Requirement": f"{code}: {req.get('description', '')[:30]}...",
+                            "Completion (%)": completion,
+                            "Status": "Complete" if completion >= 100 else "In Progress" if completion > 0 else "Not Started",
+                            "Required": req.get('required', 0),
+                            "Completed": req.get('completed', 0),
+                            "Remaining": max(0, float(req.get('required', 0)) - float(req.get('completed', 0)))
+                        })
+            else:
+                req_data = []
+                credits = parsed_data.get('academic_summary', {}).get('credits', {})
+                for subject, info in credits.items():
+                    if info.get('required') and info.get('earned'):
+                        completion = (info['earned'] / info['required']) * 100 if info['required'] > 0 else 0
+                        req_data.append({
+                            "Requirement": subject,
+                            "Completion (%)": completion,
+                            "Status": "Complete" if completion >= 100 else "In Progress" if completion > 0 else "Not Started",
+                            "Required": info.get('required', 0),
+                            "Completed": info.get('earned', 0),
+                            "Remaining": max(0, info.get('required', 0) - info.get('earned', 0))
+                        })
             
             if not req_data:
                 return None
@@ -999,20 +1104,35 @@ class DataVisualizer:
     
     def create_credits_distribution_visualization(self, parsed_data: Dict):
         try:
-            core_credits = sum(
-                req['completed'] for req in parsed_data.get('requirements', {}).values() 
-                if req and req.get('code', '').split('-')[0] in ['A', 'B', 'C', 'D']
-            )
-            
-            elective_credits = sum(
-                req['completed'] for req in parsed_data.get('requirements', {}).values() 
-                if req and req.get('code', '').split('-')[0] in ['G', 'H']
-            )
-            
-            other_credits = sum(
-                req['completed'] for req in parsed_data.get('requirements', {}).values() 
-                if req and req.get('code', '').split('-')[0] in ['E', 'F']
-            )
+            if parsed_data.get('format') == 'progress_summary':
+                core_credits = sum(
+                    req['completed'] for req in parsed_data.get('requirements', {}).values() 
+                    if req and req.get('code', '').split('-')[0] in ['A', 'B', 'C', 'D']
+                )
+                
+                elective_credits = sum(
+                    req['completed'] for req in parsed_data.get('requirements', {}).values() 
+                    if req and req.get('code', '').split('-')[0] in ['G', 'H']
+                )
+                
+                other_credits = sum(
+                    req['completed'] for req in parsed_data.get('requirements', {}).values() 
+                    if req and req.get('code', '').split('-')[0] in ['E', 'F']
+                )
+            else:
+                credits = parsed_data.get('academic_summary', {}).get('credits', {})
+                core_credits = sum(
+                    info['earned'] for subject, info in credits.items()
+                    if subject.split()[0] in ['ENGLISH', 'ALGEBRA1', 'GEOMETRY', 'MATHEMATICS', 'BIOLOGY', 'SCIENCE']
+                )
+                elective_credits = sum(
+                    info['earned'] for subject, info in credits.items()
+                    if subject.split()[0] in ['ELECTIVE', 'WORLD']
+                )
+                other_credits = sum(
+                    info['earned'] for subject, info in credits.items()
+                    if subject.split()[0] in ['ARTS', 'PHYSICAL', 'PERFORMING']
+                )
             
             credit_values = [core_credits, elective_credits, other_credits]
             credit_labels = ['Core Subjects', 'Electives', 'Arts/PE']
@@ -1171,7 +1291,7 @@ class EnhancedProfileManager:
                 "study_plan": study_plan if study_plan else {},
                 "session_token": self.current_session,
                 "last_updated": time.time(),
-                "version": "2.0"
+                "version": "2.1"
             }
             
             filepath = self.get_profile_path(name)
@@ -1237,7 +1357,7 @@ class EnhancedProfileManager:
                 if time.time() - profile_data.get('last_updated', 0) > SESSION_TIMEOUT:
                     raise gr.Error("Session expired. Please start a new session.")
                 
-                if profile_data.get('version', '1.0') == '2.0':
+                if profile_data.get('version', '1.0') in ['2.0', '2.1']:
                     try:
                         profile_data['name'] = self.encryptor.decrypt(profile_data['name'])
                         profile_data['interests'] = self.encryptor.decrypt(profile_data.get('interests', ''))
@@ -1270,7 +1390,7 @@ class EnhancedProfileManager:
             try:
                 with open(p, "r", encoding='utf-8') as f:
                     data = json.load(f)
-                    if data.get('version', '1.0') == '2.0':
+                    if data.get('version', '1.0') in ['2.0', '2.1']:
                         try:
                             name = self.encryptor.decrypt(data['name'])
                             profile_names.append(name)
@@ -1339,7 +1459,15 @@ class EnhancedTeachingAssistant:
             self._update_context(message, history)
             
             student_name = profile.get('name', 'Student')
-            gpa = profile.get('transcript', {}).get('student_info', {}).get('weighted_gpa', None)
+            transcript = profile.get('transcript', {})
+            
+            if transcript.get('format') == 'progress_summary':
+                gpa = transcript.get('student_info', {}).get('weighted_gpa', None)
+                service_hours = transcript.get('student_info', {}).get('community_service_hours', 0)
+            else:
+                gpa = transcript.get('academic_summary', {}).get('gpa', {}).get('district', None)
+                service_hours = transcript.get('assessments', {}).get('community_service', {}).get('hours', 0)
+            
             learning_style = re.search(r"Your primary learning style is\s*\*\*(.*?)\*\*", 
                                       profile.get('learning_style', ''))
             learning_style = learning_style.group(1) if learning_style else None
@@ -1349,6 +1477,8 @@ class EnhancedTeachingAssistant:
                 context += f"{student_name}'s current weighted GPA is {gpa}. "
             if learning_style:
                 context += f"They are a {learning_style.lower()} learner. "
+            if service_hours:
+                context += f"They have completed {service_hours} community service hours. "
             
             if self.context_history:
                 context += "Recent conversation:\n"
@@ -1400,29 +1530,45 @@ class EnhancedTeachingAssistant:
             return await self._generate_general_response(message, context)
     
     def _generate_gpa_response(self, profile: Dict) -> str:
-        gpa = profile.get('transcript', {}).get('student_info', {}).get('weighted_gpa', None)
-        if not gpa:
-            return "I couldn't find your GPA information. Please upload your transcript first."
-        
-        analysis = academic_analyzer.analyze_gpa(profile['transcript'])
+        transcript = profile.get('transcript', {})
+        analysis = academic_analyzer.analyze_gpa(transcript)
         response = [
             f"## 📊 GPA Analysis",
             f"**Rating:** {analysis['rating']}",
             f"{analysis['description']}",
             f"{analysis['comparison']}",
             "",
-            f"## 🎓 Graduation Status",
-            analysis['status'],
-            f"**Completion:** {analysis['completion_percentage']:.1f}%",
-            "",
-            f"## 🏫 College Recommendations"
+            f"## 🎓 Graduation Status"
         ]
         
+        grad_status = academic_analyzer.analyze_graduation_status(transcript)
+        response.append(grad_status['status'])
+        response.append(f"**Completion:** {grad_status['completion_percentage']:.1f}%")
+        
+        if grad_status.get('missing_requirements'):
+            response.append("\n**Missing Requirements:**")
+            for req in grad_status['missing_requirements'][:3]:  # Show top 3 missing
+                if transcript.get('format') == 'progress_summary':
+                    response.append(f"- {req['code']}: {req['description']} ({req['remaining']} credits remaining)")
+                else:
+                    response.append(f"- {req['subject']}: {req['remaining']} credits remaining")
+        
+        response.append("\n## 🏫 College Recommendations")
+        college_recs = academic_analyzer.generate_college_recommendations(transcript)
+        
+        if college_recs['reach']:
+            response.append("\n**Reach Schools:**")
+            response.extend([f"- {school}" for school in college_recs['reach'][:3]])
+        
+        if college_recs['target']:
+            response.append("\n**Target Schools:**")
+            response.extend([f"- {school}" for school in college_recs['target'][:3]])
+        
         if analysis.get('improvement_tips'):
             response.append("\n**Improvement Tips:**")
             response.extend([f"- {tip}" for tip in analysis['improvement_tips']])
         
-        return "\n\n".join(response)
+        return "\n".join(response)
     
     def _generate_study_response(self, profile: Dict) -> str:
         learning_style_match = re.search(r"Your primary learning style is\s*\*\*(.*?)\*\*", 
@@ -1461,7 +1607,7 @@ class EnhancedTeachingAssistant:
             elif learning_style.lower() == 'kinesthetic':
                 response.extend([
                     "- Use hands-on activities when possible",
-                    "- Study while moving or pacing",
+                    "- Study while walking or pacing",
                     "- Create physical models to represent concepts"
                 ])
         
@@ -1469,7 +1615,7 @@ class EnhancedTeachingAssistant:
             response.append("\n**Time Management Tips:**")
             response.extend([f"- {tip}" for tip in study_plan['time_management_tips']])
         
-        return "\n\n".join(response)
+        return "\n".join(response)
     
     def _generate_courses_response(self, profile: Dict) -> str:
         transcript = profile.get('transcript', {})
@@ -1478,12 +1624,14 @@ class EnhancedTeachingAssistant:
         
         current_courses = [
             course for course in transcript['course_history']
-            if course.get('status', '').lower() == 'in progress'
+            if (course.get('status', '').lower() == 'in progress' or 
+                (isinstance(course.get('credit_earned'), float) and course['credit_earned'] == 0))
         ]
         
         completed_courses = [
             course for course in transcript['course_history']
-            if course.get('status', '').lower() == 'completed'
+            if (course.get('status', '').lower() == 'completed' or 
+                (isinstance(course.get('credit_earned'), float) and course['credit_earned'] > 0))
         ]
         
         response = []
@@ -1491,8 +1639,9 @@ class EnhancedTeachingAssistant:
         if current_courses:
             response.append("**Your Current Courses:**")
             for course in current_courses[:5]:
+                course_name = course.get('description') or course.get('course_title', 'Unknown')
                 response.append(
-                    f"- {course.get('description', 'Unknown')} "
+                    f"- {course_name} "
                     f"({course.get('course_code', '')})"
                 )
         else:
@@ -1501,14 +1650,15 @@ class EnhancedTeachingAssistant:
         if completed_courses:
             response.append("\n**Recently Completed Courses:**")
             for course in completed_courses[:5]:
-                grade = course.get('grade_earned', '')
+                course_name = course.get('description') or course.get('course_title', 'Unknown')
+                grade = course.get('grade_earned', '') or course.get('grade', '')
                 if grade:
                     response.append(
-                        f"- {course.get('description', 'Unknown')} "
+                        f"- {course_name} "
                         f"(Grade: {grade})"
                     )
                 else:
-                    response.append(f"- {course.get('description', 'Unknown')}")
+                    response.append(f"- {course_name}")
         
         rigor = academic_analyzer.analyze_course_rigor(transcript)
         if rigor['rating']:
@@ -1590,13 +1740,14 @@ class EnhancedTeachingAssistant:
         
         current_courses = [
             course for course in transcript.get('course_history', [])
-            if course.get('status', '').lower() == 'in progress'
+            if (course.get('status', '').lower() == 'in progress' or 
+                (isinstance(course.get('credit_earned'), float) and course['credit_earned'] == 0))
         ]
         
         if current_courses:
             response.append("\n**Course-Specific Resources:**")
             for course in current_courses[:2]:
-                course_name = course.get('description', 'your course')
+                course_name = course.get('description') or course.get('course_title', 'your course')
                 if 'MATH' in course_name.upper():
                     response.append(f"- For {course_name}: Desmos Graphing Calculator, Art of Problem Solving")
                 elif 'SCIENCE' in course_name.upper():
@@ -1915,10 +2066,6 @@ def create_enhanced_interface():
                             results.append("\n**Target Schools:**")
                             results.extend([f"- {school}" for school in college_recs['target'][:3]])
                         
-                        if college_recs['safety']:
-                            results.append("\n**Safety Schools:**")
-                            results.extend([f"- {school}" for school in college_recs['safety'][:3]])
-                        
                         if gpa_analysis.get('improvement_tips'):
                             results.append("\n**Improvement Tips:**")
                             results.extend([f"- {tip}" for tip in gpa_analysis['improvement_tips']])