Update app.py

app.py

@@ -85,94 +85,122 @@ def extract_text_with_ocr(file_path: str) -> str:
 
 # ========== TRANSCRIPT PARSING ==========
 def extract_gpa(text: str, gpa_type: str) -> str:
-    """Extract GPA information from text with validation."""
-    patterns = [
-        rf'{gpa_type}\s*GPA\s*:\s*([\d\.]+)',  # "Weighted GPA: 3.5"
-        rf'{gpa_type}\s*GPA\s*([\d\.]+)',      # "Weighted GPA 3.5"
-        rf'{gpa_type}\s*:\s*([\d\.]+)',        # "Weighted: 3.5"
-        rf'{gpa_type}\s*([\d\.]+)'             # "Weighted 3.5"
+    """More robust GPA extraction with multiple patterns."""
+    gpa_patterns = [
+        rf'{gpa_type}\s*GPA\s*[:=]?\s*([0-5]\.\d{{2}}|\d\.\d)',  # Weighted GPA: 3.50
+        rf'{gpa_type}\s*GPA\s+([0-5]\.\d{{2}}|\d\.\d)',          # Weighted GPA 3.50
+        rf'{gpa_type}\s*[:=]?\s*([0-5]\.\d{{2}}|\d\.\d)',        # Weighted: 3.50
+        rf'GPA\s*\({gpa_type}\)\s*[:=]?\s*([0-5]\.\d{{2}}|\d\.\d)', # GPA (Weighted): 3.50
+        rf'{gpa_type}\s*[=:]?\s*([0-5]\.\d{{2}}|\d\.\d)',        # Weighted=3.50
+        rf'{gpa_type}\s*[=:]?\s*(\d\.\d{{2}})'                   # Weighted:3.50
     ]
     
-    for pattern in patterns:
+    for pattern in gpa_patterns:
         match = re.search(pattern, text, re.IGNORECASE)
         if match:
             gpa_value = match.group(1)
             try:
                 gpa_float = float(gpa_value)
-                if not 0.0 <= gpa_float <= 5.0:  # Assuming 5.0 is max for weighted GPA
+                if not 0.0 <= gpa_float <= 5.0:
                     return "Invalid GPA"
-                return gpa_value
+                return f"{gpa_float:.2f}"
             except ValueError:
                 continue
     
+    # Fallback to looking for any GPA-like number near the term
+    fallback_pattern = re.compile(rf'(?:{gpa_type}.*?)([0-5]\.\d{{1,2}})(?!\d)')
+    match = re.search(fallback_pattern, text, re.IGNORECASE)
+    if match:
+        return match.group(1)
+    
     return "N/A"
 
 def extract_courses_from_table(text: str) -> Dict[str, List[Dict]]:
-    """Extract course information with multiple pattern fallbacks."""
-    # Enhanced patterns to handle more transcript formats
+    """Enhanced course extraction with better pattern matching."""
+    # Normalize text for better matching
+    text = re.sub(r'\s+', ' ', text)  # Replace multiple spaces
+    text = text.replace('\n', ' ')     # Replace newlines
+    
+    # More robust patterns
     patterns = [
-        # Pattern 1: Structured table format
+        # Pattern for standard table format
         re.compile(
-            r'(\d{4}-\d{4})\s*'  # School year
-            r'\|?\s*(\d+)\s*'     # Grade level
-            r'\|?\s*([A-Z0-9]+)\s*'  # Course code
-            r'\|?\s*([^\|]+?)\s*'  # Course name
-            r'(?:\|\s*[^\|]*){2}'  # Skip Term and DstNumber
-            r'\|\s*([A-FW][+-]?)\s*'   # Grade (FG column)
-            r'(?:\|\s*[^\|]*)'     # Skip Incl column
-            r'\|\s*([\d\.]+|inProgress)'  # Credits
+            r'(?:Year|Term|Semester)[\s:]*(.*?)\s*'  # Year/Semester
+            r'(?:Grade|Level)[\s:]*(.*?)\s*'         # Grade level
+            r'(?:Course\s*Code|Code)[\s:]*(.*?)\s*'  # Course code
+            r'(?:Course\s*Name|Title)[\s:]*(.*?)\s*' # Course name
+            r'(?:Grade|Mark)[\s:]*(.*?)\s*'          # Grade
+            r'(?:Credits|Units)[\s:]*(.*?)(?:\s|$)'  # Credits
         ),
-        # Pattern 2: Less structured format
+        # Pattern for condensed format
         re.compile(
-            r'(\d{4}-\d{4})\s+'  # School year
-            r'(\d+)\s+'          # Grade level
-            r'([A-Z0-9]+)\s+'     # Course code
-            r'(.+?)\s+'           # Course name
-            r'([A-FW][+-]?)\s*'       # Grade
-            r'([\d\.]+|inProgress)'  # Credits
+            r'(\d{4}-\d{4}|\w+\s\d{4})\s+'  # Year range or Semester Year
+            r'(\d+)\s+'                     # Grade level
+            r'([A-Z]+\s*\d+[A-Z]*)\s+'      # Course code
+            r'(.+?)\s+'                      # Course name
+            r'([A-F][+-]?|P|F|W|I)\s+'      # Grade
+            r'(\d+\.?\d*)'                   # Credits
         ),
-        # Pattern 3: Semester-based format
+        # Fallback pattern for less structured data
         re.compile(
-            r'(Fall|Spring|Summer)\s+(\d{4})\s+'  # Term and year
-            r'(\d+)\s+'          # Grade level
-            r'([A-Z0-9]+)\s+'     # Course code
-            r'(.+?)\s+'           # Course name
-            r'([A-FW][+-]?)\s*'       # Grade
-            r'([\d\.]+)'          # Credits
+            r'([A-Z]+\s*\d+[A-Z]*)\s+'      # Course code
+            r'(.+?)\s+'                      # Course name
+            r'(?:Grade\s*:\s*)?([A-F][+-]?|P|F|W|I)\s*'  # Grade
+            r'(?:Credits\s*:\s*)?(\d+\.?\d*)'            # Credits
         )
     ]
     
     courses_by_grade = defaultdict(list)
+    extracted_courses = set()  # To avoid duplicates
     
     for pattern in patterns:
         for match in re.finditer(pattern, text):
             if len(match.groups()) == 6:
-                year_range, grade_level, course_code, course_name, grade, credits = match.groups()
-                term = None
+                year, grade, code, name, grade_mark, credits = match.groups()
             else:
-                term, year, grade_level, course_code, course_name, grade, credits = match.groups()
-                year_range = f"{term} {year}"
+                # Handle shorter patterns
+                code, name, grade_mark, credits = match.groups()[:4]
+                year = "Unknown"
+                grade = "Unknown"
             
-            # Clean and format course information
-            course_name = course_name.strip()
-            if 'DE:' in course_name:
-                course_name = course_name.replace('DE:', 'Dual Enrollment:')
-            if 'AP' in course_name and 'AP ' not in course_name:
-                course_name = course_name.replace('AP', 'AP ')
+            # Create unique identifier to avoid duplicates
+            course_id = f"{code}_{name}_{year}"
+            if course_id in extracted_courses:
+                continue
+            extracted_courses.add(course_id)
+            
+            # Clean and format data
+            code = code.strip()
+            name = name.strip()
+            if 'AP' in code and 'AP ' not in code:
+                code = code.replace('AP', 'AP ')
+            if 'DE' in code and 'DE ' not in code:
+                code = code.replace('DE', 'DE ')
             
             course_info = {
-                'name': f"{course_code} {course_name}",
-                'year': year_range,
-                'credits': credits if credits != 'inProgress' else 'In Progress'
+                'code': code,
+                'name': name,
+                'grade': grade_mark.strip() if grade_mark else None,
+                'credits': credits if credits else '0',
+                'year': year.strip() if year else 'Unknown'
             }
             
-            if grade and grade.strip():
-                course_info['grade'] = grade.strip()
-            
-            courses_by_grade[grade_level].append(course_info)
-        
-        if courses_by_grade:  # If we found matches with this pattern, stop
-            break
+            courses_by_grade[grade.strip() if grade else 'Unknown'].append(course_info)
+    
+    # If no courses found with patterns, try a more aggressive approach
+    if not courses_by_grade:
+        # Look for anything that looks like a course code followed by description
+        fallback_pattern = re.compile(r'([A-Z]+\s*\d+[A-Z]*)\s+(.+?)(?:\s+([A-F][+-]?|P|F|W|I))?(?:\s+(\d+\.?\d*))?')
+        for match in re.finditer(fallback_pattern, text):
+            code, name, grade_mark, credits = match.groups()
+            course_info = {
+                'code': code.strip(),
+                'name': name.strip(),
+                'grade': grade_mark.strip() if grade_mark else None,
+                'credits': credits if credits else '0',
+                'year': 'Unknown'
+            }
+            courses_by_grade['Unknown'].append(course_info)
     
     return courses_by_grade
 
@@ -237,7 +265,7 @@ def parse_transcript(file_obj) -> Tuple[str, Optional[Dict]]:
         for grade in sorted(courses_by_grade.keys(), key=lambda x: int(x) if x.isdigit() else x):
             output_text += f"\nGrade {grade}:\n{'-'*30}\n"
             for course in courses_by_grade[grade]:
-                output_text += f"- {course['name']}"
+                output_text += f"- {course['code']} {course['name']}"
                 if 'grade' in course and course['grade']:
                     output_text += f" (Grade: {course['grade']})"
                 if 'credits' in course:
@@ -614,7 +642,7 @@ class ProfileManager:
             for grade in sorted(courses_by_grade.keys(), key=lambda x: int(x) if x.isdigit() else x):
                 display += f"\n**Grade {grade}**\n"
                 for course in courses_by_grade[grade]:
-                    display += f"- {course.get('name', 'Unnamed course')}"
+                    display += f"- {course.get('code', '')} {course.get('name', 'Unnamed course')}"
                     if 'grade' in course and course['grade']:
                         display += f" (Grade: {course['grade']})"
                     if 'credits' in course:
@@ -787,7 +815,7 @@ class TeachingAssistant:
         for grade_level, course_list in courses.items():
             for course in course_list:
                 if course.get('grade', '').upper() in ['D', 'F']:
-                    weak_subjects.append(course.get('name', 'Unknown course'))
+                    weak_subjects.append(f"{course.get('code', '')} {course.get('name', 'Unknown course')}")
         
         if weak_subjects:
             response += ("**Areas for Improvement**:\n"
@@ -823,7 +851,7 @@ class TeachingAssistant:
         for grade in sorted(courses.keys(), key=lambda x: int(x) if x.isdigit() else x):
             response += f"\n**Grade {grade}**:\n"
             for course in courses[grade]:
-                response += f"- {course.get('name', 'Unnamed course')}"
+                response += f"- {course.get('code', '')} {course.get('name', 'Unnamed course')}"
                 if 'grade' in course:
                     response += f" (Grade: {course['grade']})"
                 response += "\n"
@@ -1100,6 +1128,9 @@ def create_interface():
                                 placeholder="e.g., Science, Music, Sports, Art..."
                             )
                         
+                        save_personal_btn = gr.Button("Save Information", variant="primary")
+                        save_confirmation = gr.HTML(visible=False)
+                        
                         gr.Markdown("### Favorites")
                         with gr.Group():
                             movie = gr.Textbox(label="Favorite Movie")
@@ -1130,29 +1161,17 @@ def create_interface():
                             outputs=blog_text
                         )
                 
-                # Check if required fields are filled to mark as complete
-                def check_personal_info_complete(name, age, interests, current_tab_status):
+                def save_personal_info(name, age, interests, current_tab_status):
                     if name.strip() and age and interests.strip():
                         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(visible=False)
-                    return current_tab_status, gr.update(), gr.update(), gr.update()
+                        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)
+                    return current_tab_status, gr.update(), gr.update(), gr.update(visible=False), gr.update(visible=True)
                 
-                # Monitor changes to required fields
-                name.change(
-                    fn=check_personal_info_complete,
-                    inputs=[name, age, interests, tab_completed],
-                    outputs=[tab_completed, step3, step4, nav_message]
-                )
-                age.change(
-                    fn=check_personal_info_complete,
+                save_personal_btn.click(
+                    fn=save_personal_info,
                     inputs=[name, age, interests, tab_completed],
-                    outputs=[tab_completed, step3, step4, nav_message]
-                )
-                interests.change(
-                    fn=check_personal_info_complete,
-                    inputs=[name, age, interests, tab_completed],
-                    outputs=[tab_completed, step3, step4, nav_message]
+                    outputs=[tab_completed, step3, step4, save_confirmation, nav_message]
                 )
             
             # ===== TAB 4: Save & Review =====
@@ -1251,7 +1270,7 @@ def create_interface():
                     fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
                     outputs=load_btn
                 ).then(
-                    fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
+                    fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value)))),
                     outputs=delete_btn
                 )
                 
@@ -1301,34 +1320,35 @@ def create_interface():
                 # Check if current tab is completed
                 if not tab_completed_status.get(current_tab, False):
                     return gr.Tabs(selected=current_tab), \
-                           gr.update(value=f"<div class='nav-message'>Please complete the current tab before proceeding to tab {tab_index + 1}</div>", visible=True)
+                           gr.update(value=f"<div class='nav-message'>Please complete the current tab before proceeding to tab {tab_index + 1}</div>", visible=True), \
+                           gr.update(visible=False)
             
-            return gr.Tabs(selected=tab_index), gr.update(visible=False)
+            return gr.Tabs(selected=tab_index), gr.update(visible=False), gr.update(visible=False)
         
         step1.click(
             fn=lambda idx, status: navigate_to_tab(idx, status),
             inputs=[gr.State(0), tab_completed],
-            outputs=[tabs, nav_message]
+            outputs=[tabs, nav_message, quiz_alert]
         )
         step2.click(
             fn=lambda idx, status: navigate_to_tab(idx, status),
             inputs=[gr.State(1), tab_completed],
-            outputs=[tabs, nav_message]
+            outputs=[tabs, nav_message, quiz_alert]
         )
         step3.click(
             fn=lambda idx, status: navigate_to_tab(idx, status),
             inputs=[gr.State(2), tab_completed],
-            outputs=[tabs, nav_message]
+            outputs=[tabs, nav_message, quiz_alert]
         )
         step4.click(
             fn=lambda idx, status: navigate_to_tab(idx, status),
             inputs=[gr.State(3), tab_completed],
-            outputs=[tabs, nav_message]
+            outputs=[tabs, nav_message, quiz_alert]
         )
         step5.click(
             fn=lambda idx, status: navigate_to_tab(idx, status),
             inputs=[gr.State(4), tab_completed],
-            outputs=[tabs, nav_message]
+            outputs=[tabs, nav_message, quiz_alert]
         )
     
     return app