Update app.py

app.py

@@ -252,26 +252,10 @@ class LearningStyleQuiz:
 # Initialize learning style quiz
 learning_style_quiz = LearningStyleQuiz()
 
-# ========== TRANSCRIPT PARSER ==========
-class MiamiDadeTranscriptParser:
+# ========== ENHANCED TRANSCRIPT PARSER ==========
+class EnhancedMiamiDadeTranscriptParser:
     def __init__(self):
-        # 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.format2_patterns = {
+        self.patterns = {
             'student_info': re.compile(
                 r"LEGAL NAME:\s*([A-Z]+,\s*[A-Z]+).*?"
                 r"GRADE LEVEL:\s*(\d+).*?"
@@ -297,98 +281,42 @@ class MiamiDadeTranscriptParser:
                 r"BIOLOGY ASSESSMENT PASSED|"
                 r"DISTRICT COMM/VOL SERVICE RQMT MET:\s*(YES).*?HRS:\s*(\d+)",
                 re.DOTALL
+            ),
+            'class_rank': re.compile(
+                r"\*\s+PERCENTILE:\s*(\d+)\s*\*\s*TOTAL NUMBER IN CLASS:\s*(\d+)",
+                re.DOTALL
             )
         }
-
+        
     def parse_transcript(self, file_path: str) -> Dict:
-        """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)
-            
-            # Clean up text
-            text = re.sub(r'\s+', ' ', text)
-            text = re.sub(r'(?<=\d)\s+(?=\d)', '', text)
-            
-            # 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_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 {}
-            
-        return {
-            'id': match.group(1),
-            'name': match.group(2).strip(),
-            'grade': match.group(3),
-            'year_of_graduation': match.group(4),
-            'weighted_gpa': float(match.group(5)),
-            'community_service_date': match.group(6),
-            'total_credits': float(match.group(7)),
-            'district': 'Miami-Dade'
-        }
-
-    def _parse_format1_requirements(self, text: str) -> Dict:
-        """Parse graduation requirements section from format 1"""
-        requirements = {}
-        for match in self.format1_patterns['requirement'].finditer(text):
-            requirements[match.group(1).strip()] = {
-                'description': match.group(2).strip(),
-                'required': float(match.group(3)),
-                'waived': float(match.group(4)),
-                'completed': float(match.group(5)),
-                'percent_complete': float(match.group(6))
-            }
-        return requirements
-
-    def _parse_format1_courses(self, text: str) -> List[Dict]:
-        """Parse course history section from format 1"""
-        courses = []
-        for match in self.format1_patterns['course'].finditer(text):
-            courses.append({
-                'requirement': match.group(1).strip(),
-                'school_year': match.group(2),
-                'grade_level': match.group(3),
-                'course_code': match.group(4),
-                'description': match.group(5).strip(),
-                'term': match.group(6),
-                'district_number': match.group(7),
-                'included': match.group(8),
-                'credits': 0 if 'inProgress' in match.group(9) else float(match.group(9)),
-                'status': 'In Progress' if 'inProgress' in match.group(9) else 'Completed'
-            })
-        return courses
+        """Parse Miami-Dade transcript PDF with enhanced pattern matching"""
+        try:
+            with pdfplumber.open(file_path) as pdf:
+                text = "\n".join(page.extract_text() for page in pdf.pages)
+                
+                # Clean up text
+                text = re.sub(r'\s+', ' ', text)
+                text = re.sub(r'(?<=\d)\s+(?=\d)', '', text)
+                
+                return self._parse_format(text)
+        except Exception as e:
+            logger.error(f"Error parsing transcript: {str(e)}")
+            raise ValueError(f"Error processing transcript: {str(e)}")
 
-    def _parse_format2(self, text: str) -> Dict:
-        """Parse the second transcript format"""
+    def _parse_format(self, text: str) -> Dict:
+        """Parse the transcript format shown in the example"""
         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'
+            'student_info': self._parse_student_info(text),
+            'academic_summary': self._parse_academic_summary(text),
+            'course_history': self._parse_courses(text),
+            'assessments': self._parse_assessments(text),
+            'format': 'cumulative_summary_v2'
         }
         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)
+    def _parse_student_info(self, text: str) -> Dict:
+        """Extract student information"""
+        match = self.patterns['student_info'].search(text)
         if not match:
             return {}
             
@@ -411,10 +339,11 @@ class MiamiDadeTranscriptParser:
         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)
+    def _parse_academic_summary(self, text: str) -> Dict:
+        """Parse academic summary section"""
+        gpa_match = self.patterns['gpa'].search(text)
+        credits_matches = self.patterns['credits'].finditer(text)
+        rank_match = self.patterns['class_rank'].search(text)
         
         summary = {
             'gpa': {
@@ -422,7 +351,10 @@ class MiamiDadeTranscriptParser:
                 'state': float(gpa_match.group(2)) if gpa_match else None
             },
             'credits': {},
-            'class_rank': self._extract_class_rank(text)
+            'class_rank': {
+                'percentile': int(rank_match.group(1)) if rank_match else None,
+                'class_size': int(rank_match.group(2)) if rank_match else None
+            }
         }
         
         for match in credits_matches:
@@ -435,21 +367,10 @@ class MiamiDadeTranscriptParser:
             
         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"""
+    def _parse_courses(self, text: str) -> List[Dict]:
+        """Parse course history section"""
         courses = []
-        for match in self.format2_patterns['course'].finditer(text):
+        for match in self.patterns['course'].finditer(text):
             courses.append({
                 'term': match.group(1),
                 'course_code': match.group(2),
@@ -463,9 +384,9 @@ class MiamiDadeTranscriptParser:
             })
         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)
+    def _parse_assessments(self, text: str) -> Dict:
+        """Parse assessment and requirement information"""
+        matches = self.patterns['assessment'].finditer(text)
         assessments = {
             'ela_passed_date': None,
             'algebra_passed': False,
@@ -491,8 +412,8 @@ class MiamiDadeTranscriptParser:
                 
         return assessments
 
-# Initialize transcript parser
-transcript_parser = MiamiDadeTranscriptParser()
+# Initialize the enhanced parser
+transcript_parser = EnhancedMiamiDadeTranscriptParser()
 
 # ========== ACADEMIC ANALYZER ==========
 class AcademicAnalyzer:
@@ -600,7 +521,6 @@ class AcademicAnalyzer:
         
         try:
             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))
@@ -628,7 +548,6 @@ class AcademicAnalyzer:
                     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) 
@@ -1466,7 +1385,7 @@ class EnhancedTeachingAssistant:
                 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)
+                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', ''))