Update app.py

app.py

@@ -23,6 +23,7 @@ import asyncio
 from functools import lru_cache
 import hashlib
 from concurrent.futures import ThreadPoolExecutor
+from pydantic import BaseModel
 
 # ========== CONFIGURATION ==========
 PROFILES_DIR = "student_profiles"
@@ -244,6 +245,33 @@ def remove_sensitive_info(text: str) -> str:
     return text
 
 # ========== TRANSCRIPT PARSING ==========
+class Course(BaseModel):
+    requirement: str
+    school_year: str
+    grade_level: str
+    course_code: str
+    description: str
+    term: str
+    district_number: str
+    fg: str
+    included: str
+    credits: str
+
+class GraduationProgress(BaseModel):
+    student_name: str
+    student_id: str
+    current_grade: str
+    year_of_graduation: str
+    unweighted_gpa: float
+    weighted_gpa: float
+    community_service_hours: int
+    community_service_date: str
+    total_credits_earned: float
+    virtual_grade: str
+    requirements: Dict[str, Dict[str, float]]
+    courses: List[Course]
+    assessments: Dict[str, str]
+
 class TranscriptParser:
     def __init__(self):
         self.student_data = {}
@@ -253,27 +281,98 @@ class TranscriptParser:
         self.graduation_status = {}
         
     def parse_transcript(self, text: str) -> Dict:
-        """Simplified transcript parser that extracts key information"""
+        """Parse transcript text and return structured data"""
+        try:
+            # First try the new detailed parser
+            parsed_data = self._parse_detailed_transcript(text)
+            if parsed_data:
+                return parsed_data
+            
+            # Fall back to simplified parser if detailed parsing fails
+            return self._parse_simplified_transcript(text)
+            
+        except Exception as e:
+            logging.error(f"Error parsing transcript: {str(e)}")
+            raise ValueError(f"Couldn't parse transcript: {str(e)}")
+
+    def _parse_detailed_transcript(self, text: str) -> Optional[Dict]:
+        """Parse detailed transcript format"""
         try:
             parsed_data = {
                 'student_info': {},
-                'course_history': []
+                'requirements': {},
+                'course_history': [],
+                'assessments': {}
             }
             
-            # 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()
+            # Extract student info
+            student_info_match = re.search(r"(\d{7}) - (.*?)\n", text)
+            if student_info_match:
+                parsed_data['student_info']['id'] = student_info_match.group(1)
+                parsed_data['student_info']['name'] = student_info_match.group(2).strip()
+            
+            current_grade_match = re.search(r"Current Grade: (\d+)", text)
+            if current_grade_match:
+                parsed_data['student_info']['grade'] = current_grade_match.group(1)
+            
+            yog_match = re.search(r"YOG (\d{4})", text)
+            if yog_match:
+                parsed_data['student_info']['year_of_graduation'] = yog_match.group(1)
+            
+            unweighted_gpa_match = re.search(r"Un-weighted GPA (\d+\.\d+)", text)
+            if unweighted_gpa_match:
+                parsed_data['student_info']['unweighted_gpa'] = float(unweighted_gpa_match.group(1))
+            
+            weighted_gpa_match = re.search(r"Weighted GPA (\d+\.\d+)", text)
+            if weighted_gpa_match:
+                parsed_data['student_info']['weighted_gpa'] = float(weighted_gpa_match.group(1))
+            
+            service_hours_match = re.search(r"Comm Serv Hours (\d+)", text)
+            if service_hours_match:
+                parsed_data['student_info']['community_service_hours'] = int(service_hours_match.group(1))
             
-            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()
+            service_date_match = re.search(r"Comm Serv Date (\d{2}/\d{2}/\d{4})", text)
+            if service_date_match:
+                parsed_data['student_info']['community_service_date'] = service_date_match.group(1)
             
-            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))
+            credits_match = re.search(r"Total Credits Earned (\d+\.\d+)", text)
+            if credits_match:
+                parsed_data['student_info']['total_credits'] = float(credits_match.group(1))
             
-            # Extract courses (simplified pattern)
+            virtual_grade_match = re.search(r"Virtual Grade (\w+)", text)
+            if virtual_grade_match:
+                parsed_data['student_info']['virtual_grade'] = virtual_grade_match.group(1)
+            
+            # Extract requirements
+            req_pattern = re.compile(r"([A-Z]-.*?)\s*\|\s*(.*?)\s*\|\s*(\d+\.\d+)\s*\|\s*(\d+\.\d+)\s*\|\s*(\d+\.\d+)\s*\|\s*(\d+) %")
+            for match in req_pattern.finditer(text):
+                code = match.group(1).strip()
+                desc = match.group(2).strip()
+                required = float(match.group(3))
+                waived = float(match.group(4))
+                completed = float(match.group(5))
+                percent = float(match.group(6))
+                parsed_data['requirements'][code] = {
+                    "description": desc,
+                    "required": required,
+                    "waived": waived,
+                    "completed": completed,
+                    "percent_complete": percent
+                }
+            
+            # Extract assessments
+            assess_pattern = re.compile(r"Z-Assessment: (.*?)\s*\|\s*(.*?)\s*\|\s*(\w+)\s*\|\s*(\d+) %")
+            for match in assess_pattern.finditer(text):
+                name = f"Assessment: {match.group(1)}"
+                status = match.group(3)
+                parsed_data['assessments'][name] = status
+            
+            for z_item in ["Community Service Hours", "GPA"]:
+                if re.search(fr"Z-{z_item.replace(' ', '.*?')}\s*\|\s*(.*?)\s*\|\s*(\w+)\s*\|\s*(\d+) %", text):
+                    status = re.search(fr"Z-{z_item.replace(' ', '.*?')}\s*\|\s*(.*?)\s*\|\s*(\w+)\s*\|\s*(\d+) %", text).group(2)
+                    parsed_data['assessments'][z_item] = status
+            
+            # Extract courses (simplified for now - can be enhanced)
             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:
@@ -287,8 +386,41 @@ class TranscriptParser:
             return parsed_data
             
         except Exception as e:
-            logging.error(f"Error parsing transcript: {str(e)}")
-            raise ValueError(f"Couldn't parse transcript: {str(e)}")
+            logging.warning(f"Detailed transcript parsing failed, falling back to simple parser: {str(e)}")
+            return None
+
+    def _parse_simplified_transcript(self, text: str) -> Dict:
+        """Fallback simplified transcript parser that extracts key information"""
+        parsed_data = {
+            'student_info': {},
+            'course_history': []
+        }
+        
+        # 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()
+        
+        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()
+        
+        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))
+        
+        # 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])
+            })
+        
+        return parsed_data
 
 def parse_transcript(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Dict]]:
     """Process transcript file and return simple confirmation"""