Update app.py

app.py

@@ -173,7 +173,7 @@ def validate_age(age: Union[int, float, str]) -> int:
 def validate_file(file_obj) -> None:
     """Validate uploaded file."""
     if not file_obj:
-        raise ValueError("Please upload a file first.")
+        raise ValueError("Please upload a file first")
     
     file_ext = os.path.splitext(file_obj.name)[1].lower()
     if file_ext not in ALLOWED_FILE_TYPES:
@@ -319,149 +319,122 @@ class TranscriptParser:
             raise ValueError(f"Couldn't parse transcript: {str(e)}")
 
     def _parse_miami_dade_format(self, text: str) -> Dict:
-        """More flexible parser for Miami-Dade County Public Schools transcripts."""
-        # Normalize text first
-        text = re.sub(r'\s+', ' ', text)  # Collapse multiple spaces
-        
-        # More flexible student info extraction
-        student_match = re.search(
-            r'(?:Student\s*ID[:]?\s*(\d+).*?Name[:]?\s*([A-Za-z\s,]+).*?'
-            r'(?:Grade|Level)[:]?\s*(\d+).*?'
-            r'(?:Grad|YOG)[:]?\s*(\d{4}).*?'
-            r'(?:Unweighted\s*GPA)[:]?\s*([\d.]+).*?'
-            r'(?:Weighted\s*GPA)[:]?\s*([\d.]+).*?'
-            r'(?:Total\s*Credits)[:]?\s*([\d.]+).*?'
-            r'(?:Comm\s*Serv|Service\s*Hours)[:]?\s*(\d+)',
-            text, re.IGNORECASE | re.DOTALL
-        )
-
-        if student_match:
-            self.student_data = {
-                "id": student_match.group(1).strip(),
-                "name": student_match.group(2).replace(",", ", ").strip().title(),
-                "current_grade": student_match.group(3),
-                "graduation_year": student_match.group(4),
-                "unweighted_gpa": float(student_match.group(5)),
-                "weighted_gpa": float(student_match.group(6)),
-                "total_credits": float(student_match.group(7)),
-                "community_service_hours": int(student_match.group(8))
-            }
-        else:
-            # Fallback pattern if first one fails
-            student_match = re.search(
-                r'(\d{7})\s*(.*?)\s*(?:Grade|Grd)[:]?\s*(\d+)',
-                text, re.IGNORECASE
-            )
-            if student_match:
-                self.student_data = {
-                    "id": student_match.group(1).strip(),
-                    "name": student_match.group(2).strip().title(),
-                    "current_grade": student_match.group(3),
-                    "graduation_year": "",
-                    "unweighted_gpa": 0.0,
-                    "weighted_gpa": 0.0,
-                    "total_credits": 0.0,
-                    "community_service_hours": 0
-                }
-
-        # Extract requirements
-        self.requirements = {}
-        req_section = re.search(
-            r"Code\s+Description\s+Required\s+Waived\s+Completed\s+Status(.*?)Total\s+\d+\.\d+\s+\d+\.\d+\s+\d+\.\d+\s+\d+%",
-            text, re.DOTALL
-        )
-        if req_section:
-            req_lines = req_section.group(1).strip().split('\n')
-            for line in req_lines:
-                line = line.strip()
-                if not line:
-                    continue
-                    
-                req_match = re.match(r"([A-Z]-[^\s]+)\s+(.+?)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+(\d+)%", line)
-                if req_match:
-                    code = req_match.group(1).strip()
-                    self.requirements[code] = {
-                        "description": req_match.group(2).strip(),
-                        "required": float(req_match.group(3)),
-                        "waived": float(req_match.group(4)),
-                        "completed": float(req_match.group(5)),
-                        "status": f"{req_match.group(6)}%"
-                    }
-
-        # Extract course history
-        self.course_history = []
-        course_section = re.search(
-            r"Requirement\s+School Year\s+GradeLv1\s+CrsNum\s+Description\s+Term\s+DstNumber\s+FG\s+Incl\s+Credits(.*?)Legend for Incl",
-            text, re.DOTALL
-        )
+        """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': {}
+        }
         
-        if course_section:
-            course_lines = course_section.group(1).strip().split('\n')
-            for line in course_lines:
-                line = line.strip()
-                if not line or line.startswith('='):
-                    continue
+        # Parse student information
+        student_info_lines = []
+        for line in lines:
+            if "DORAL ACADEMY HIGH SCHOOL" in line:
+                student_info_lines = lines[lines.index(line):lines.index(line)+5]
+                break
+        
+        if student_info_lines:
+            # Parse school and cohort info
+            school_info = student_info_lines[0].split('|')
+            data['student_info']['school'] = school_info[1].strip()
+            data['student_info']['district'] = school_info[2].strip()
+            
+            # Parse student name and ID
+            name_id_line = student_info_lines[1].split('-')
+            data['student_info']['student_id'] = name_id_line[0].strip()
+            data['student_info']['student_name'] = name_id_line[1].split(',')[1].strip() + " " + name_id_line[1].split(',')[0].strip()
+            
+            # Parse academic info
+            academic_info = student_info_lines[2].split('|')
+            data['student_info']['current_grade'] = academic_info[1].split(':')[1].strip()
+            data['student_info']['graduation_year'] = academic_info[2].strip()
+            data['student_info']['weighted_gpa'] = academic_info[3].split(':')[1].strip()
+            data['student_info']['community_service_date'] = academic_info[4].split(':')[1].strip()
+            data['student_info']['total_credits_earned'] = academic_info[5].split(':')[1].strip()
+        
+        # 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)
+            
+            # Parse total line
+            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()]
                     
-                # Handle both regular and in-progress courses
-                course_match = re.match(
-                    r"([A-Z]-[^\s]+)?\s*(\d{4}-\d{4}|\d{4})?\s*(\d{2})?\s*([A-Z0-9]+)?\s*(.+?)\s+([AT12]+)?\s*([A-Z0-9]+)?\s*([A-Z])?\s*([A-Z])?\s*(inProgress|\d+\.\d+)?",
-                    line
-                )
-                
-                if course_match:
-                    self.course_history.append({
-                        "requirement_category": course_match.group(1) if course_match.group(1) else None,
-                        "school_year": course_match.group(2) if course_match.group(2) else None,
-                        "grade_level": course_match.group(3) if course_match.group(3) else None,
-                        "course_code": course_match.group(4) if course_match.group(4) else None,
-                        "description": course_match.group(5).strip() if course_match.group(5) else None,
-                        "term": course_match.group(6) if course_match.group(6) else None,
-                        "district_number": course_match.group(7) if course_match.group(7) else None,
-                        "grade": course_match.group(8) if course_match.group(8) else None,
-                        "inclusion_status": course_match.group(9) if course_match.group(9) else None,
-                        "credits": course_match.group(10) if course_match.group(10) else None
-                    })
-
-        # Extract in-progress courses
-        self._extract_current_courses()
-        self._calculate_completion()
-
-        return {
-            "student_info": self.student_data,
-            "requirements": self.requirements,
-            "current_courses": self.current_courses,
-            "course_history": self.course_history,
-            "graduation_status": self.graduation_status,
-            "format": "miami_dade"
+                    # 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
+        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
         }
-
-    def _extract_current_courses(self):
-        """Identify in-progress courses."""
-        self.current_courses = [
-            {
-                "course": c["description"],
-                "code": c["course_code"],
-                "category": c["requirement_category"],
-                "term": c["term"],
-                "credits": c["credits"],
-                "grade_level": c["grade_level"]
-            }
-            for c in self.course_history 
-            if c.get("credits") and isinstance(c["credits"], str) and c["credits"].lower() == "inprogress"
-        ]
-
-    def _calculate_completion(self):
-        """Compute graduation readiness."""
-        total_required = sum(req["required"] for req in self.requirements.values())
-        total_completed = sum(req["completed"] for req in self.requirements.values())
-
-        self.graduation_status.update({
-            "total_required_credits": total_required,
-            "total_completed_credits": total_completed,
-            "percent_complete": round((total_completed / total_required) * 100, 1) if total_required > 0 else 0,
-            "remaining_credits": total_required - total_completed,
-            "on_track": (total_completed / total_required) >= 0.75 if total_required > 0 else False
-        })
+        data['graduation_status'] = graduation_status
+        
+        return data
 
 def format_transcript_output(data: Dict) -> str:
     """Enhanced formatting for transcript output with format awareness"""
@@ -500,24 +473,25 @@ def format_transcript_output(data: Dict) -> str:
         
         # Detailed Requirements
         output.append("### Detailed Requirements:")
-        for code, req in data.get("requirements", {}).items():
+        for req in data.get("graduation_requirements", []):
             output.append(
-                f"- **{code}**: {req.get('description', '')}\n"
+                f"- **{req['code']}**: {req['description']}\n"
                 f"  Required: {req['required']} | Completed: {req['completed']} | "
                 f"Status: {req['status']}"
             )
         output.append("")
     
     # Current Courses
-    if data.get("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["current_courses"]:
-            output.append(
-                f"- **{course['code']} {course['course']}**\n"
-                f"  Category: {course['category']} | "
-                f"Grade Level: {course['grade_level']} | "
-                f"Term: {course['term']} | Credits: {course['credits']}"
-            )
+        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
@@ -532,9 +506,9 @@ def format_transcript_output(data: Dict) -> str:
             output.append(f"\n### {year}")
             for course in courses_by_year[year]:
                 output.append(
-                    f"- **{course.get('course_code', '')} {course.get('description', 'Unnamed course')}**\n"
-                    f"  Subject: {course.get('requirement_category', 'N/A')} | "
-                    f"Grade: {course.get('grade', 'N/A')} | "
+                    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')}"
                 )