Update app.py

app.py

@@ -14,58 +14,47 @@ except Exception as e:
     print(f"Could not load NER model: {e}")
     ner_pipeline = None
 
-# ========== IMPROVED TRANSCRIPT PARSING ==========
-def extract_gpa(text):
-    gpa_data = {'weighted': "N/A", 'unweighted': "N/A"}
-    gpa_patterns = [
-        r'Weighted GPA[\s:]*(\d\.\d{1,2})',
-        r'GPA \(Weighted\)[\s:]*(\d\.\d{1,2})',
-        r'Cumulative GPA \(Weighted\)[\s:]*(\d\.\d{1,2})',
-        r'Unweighted GPA[\s:]*(\d\.\d{1,2})',
-        r'GPA \(Unweighted\)[\s:]*(\d\.\d{1,2})',
-        r'Cumulative GPA \(Unweighted\)[\s:]*(\d\.\d{1,2})',
-        r'GPA[\s:]*(\d\.\d{1,2})'
-    ]
-    for pattern in gpa_patterns:
-        for match in re.finditer(pattern, text, re.IGNORECASE):
-            gpa_value = match.group(1)
-            if 'weighted' in pattern.lower():
-                gpa_data['weighted'] = gpa_value
-            elif 'unweighted' in pattern.lower():
-                gpa_data['unweighted'] = gpa_value
-            else:
-                if gpa_data['unweighted'] == "N/A":
-                    gpa_data['unweighted'] = gpa_value
-                if gpa_data['weighted'] == "N/A":
-                    gpa_data['weighted'] = gpa_value
-    return gpa_data
+# ========== TRANSCRIPT PARSING FUNCTIONS ==========
+def extract_gpa(text, gpa_type):
+    pattern = rf'{gpa_type}\s*([\d\.]+)'
+    match = re.search(pattern, text)
+    return match.group(1) if match else "N/A"
 
-def extract_courses_with_regex(text):
-    patterns = [
-        r'(?:^|\n)([A-Z]{2,}\s*-?\s*\d{3}[A-Z]?\b)\s*([A-F][+-]?|\d{2,3}%)?',
-        r'(?:^|\n)([A-Z][a-z]+(?:\s+[A-Z]?[a-z]+)+)\s*[:\-]?\s*([A-F][+-]?|\d{2,3}%)?',
-        r'(?:^|\n)([A-Z]{2,})\s*\d{3}\b'
-    ]
-    courses = []
-    for pattern in patterns:
-        for match in re.finditer(pattern, text, re.MULTILINE):
-            course_name = match.group(1).strip()
-            grade = match.group(2).strip() if match.group(2) else None
-            courses.append({'name': course_name, 'grade': grade})
-    return courses
-
-def extract_grade_levels(text):
-    grade_pattern = r'(?:Grade|Year|Term)\s*[:]?\s*(\d+|Freshman|Sophomore|Junior|Senior)\b'
-    grade_matches = list(re.finditer(grade_pattern, text, re.IGNORECASE))
-    grade_sections = []
-    for i, match in enumerate(grade_matches):
-        start_pos = match.start()
-        end_pos = grade_matches[i+1].start() if i+1 < len(grade_matches) else len(text)
-        grade_sections.append({
-            'grade': match.group(1),
-            'text': text[start_pos:end_pos]
-        })
-    return grade_sections
+def extract_courses_from_table(text):
+    # This pattern matches the course table rows in the transcript
+    course_pattern = 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 (captures until next pipe)
+        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
+    )
+    
+    courses_by_grade = defaultdict(list)
+    
+    for match in re.finditer(course_pattern, text):
+        year_range, grade_level, course_code, course_name, grade, credits = match.groups()
+        
+        # Clean up course name
+        course_name = course_name.strip()
+        if 'DE:' in course_name:
+            course_name = course_name.replace('DE:', 'Dual Enrollment:')
+        
+        course_info = {
+            'name': f"{course_code} {course_name}",
+            'year': year_range,
+            'credits': credits
+        }
+        
+        if grade and grade.strip():
+            course_info['grade'] = grade.strip()
+        
+        courses_by_grade[grade_level].append(course_info)
+    
+    return courses_by_grade
 
 def parse_transcript(file):
     if file.name.endswith('.pdf'):
@@ -74,83 +63,40 @@ def parse_transcript(file):
         for page in reader.pages:
             text += page.extract_text() + '\n'
         
-        # Try both NER and regex approaches
-        courses = []
-        if ner_pipeline:
-            try:
-                entities = ner_pipeline(text)
-                current_course = {}
-                for entity in entities:
-                    if entity['word'].startswith('##'):
-                        current_course['name'] = current_course.get('name', '') + entity['word'][2:]
-                    elif entity['entity'] in ['B-ORG', 'I-ORG']:  # Using ORG as proxy for courses
-                        if 'name' in current_course:
-                            courses.append(current_course)
-                        current_course = {'name': entity['word']}
-                    elif entity['entity'] == 'GRADE' and current_course:
-                        current_course['grade'] = entity['word']
-                if current_course:
-                    courses.append(current_course)
-            except Exception as e:
-                print(f"NER failed: {e}")
+        # Extract GPA information
+        gpa_data = {
+            'weighted': extract_gpa(text, 'Weighted GPA'),
+            'unweighted': extract_gpa(text, 'Un-weighted GPA')
+        }
         
-        # Fallback to regex if NER didn't find courses
-        if not courses:
-            courses = extract_courses_with_regex(text)
+        # Extract current grade level
+        grade_match = re.search(r'Current Grade:\s*(\d+)', text)
+        grade_level = grade_match.group(1) if grade_match else "Unknown"
         
-        # Organize by grade level
-        grade_sections = extract_grade_levels(text)
-        courses_by_grade = defaultdict(list)
+        # Extract all courses with grades and year taken
+        courses_by_grade = extract_courses_from_table(text)
         
-        if grade_sections:
-            for section in grade_sections:
-                section_courses = extract_courses_with_regex(section['text'])
-                for course in section_courses:
-                    course['term'] = section['grade']
-                    courses_by_grade[section['grade']].append(course)
-        else:
-            courses_by_grade["All"] = courses
+        # Prepare output text
+        output_text = f"Grade Level: {grade_level}\n"
+        output_text += f"Weighted GPA: {gpa_data['weighted']}\n"
+        output_text += f"Unweighted GPA: {gpa_data['unweighted']}\n\n"
+        output_text += "Course History:\n"
         
-        gpa_data = extract_gpa(text)
-        
-        output_text = "Transcript parsed successfully\n"
-        output_text += f"Found {len(courses)} courses across {len(courses_by_grade)} grade levels\n"
+        for grade, courses in sorted(courses_by_grade.items()):
+            output_text += f"\nGrade {grade}:\n"
+            for course in courses:
+                output_text += f"- {course['name']}"
+                if 'grade' in course:
+                    output_text += f" (Grade: {course['grade']})"
+                output_text += "\n"
         
         return output_text, {
             "gpa": gpa_data,
+            "grade_level": grade_level,
             "courses": dict(courses_by_grade)
         }
-    elif file.name.endswith('.csv'):
-        df = pd.read_csv(file)
-    elif file.name.endswith('.xlsx'):
-        df = pd.read_excel(file)
     else:
-        return "Unsupported file format", None
-
-    # Fallback for CSV/Excel
-    gpa = "N/A"
-    for col in ['GPA', 'Grade Point Average', 'Cumulative GPA']:
-        if col in df.columns:
-            gpa = df[col].iloc[0] if isinstance(df[col].iloc[0], (float, int)) else "N/A"
-            break
-
-    grade_level = "N/A"
-    for col in ['Grade Level', 'Grade', 'Class', 'Year']:
-        if col in df.columns:
-            grade_level = df[col].iloc[0]
-            break
-
-    courses = []
-    for col in ['Course', 'Subject', 'Course Name', 'Class']:
-        if col in df.columns:
-            courses = df[col].tolist()
-            break
-
-    return f"Grade Level: {grade_level}\nGPA: {gpa}", {
-        "gpa": {"unweighted": gpa, "weighted": "N/A"},
-        "grade_level": grade_level,
-        "courses": courses
-    }
+        return "Unsupported file format (PDF only for transcript parsing)", None
 
 # ========== LEARNING STYLE QUIZ ==========
 learning_style_questions = [
@@ -326,28 +272,14 @@ def transcript_display(transcript_dict):
     courses_by_grade = transcript_dict["courses"]
     
     if isinstance(courses_by_grade, dict):
-        for grade, courses in courses_by_grade.items():
-            display += f"**{grade}**\n"
+        for grade, courses in sorted(courses_by_grade.items()):
+            display += f"**Grade {grade}**\n"
             for course in courses:
-                if isinstance(course, dict):
-                    display += f"- {course.get('name', 'N/A')}"
-                    if 'grade' in course:
-                        display += f" (Grade: {course['grade']})"
-                    if 'term' in course:
-                        display += f" | Term: {course['term']}"
-                    display += "\n"
-                else:
-                    display += f"- {str(course)}\n"
-            display += "\n"
-    elif isinstance(courses_by_grade, list):
-        for course in courses_by_grade:
-            if isinstance(course, dict):
-                display += f"- {course.get('name', 'N/A')}"
+                display += f"- {course['name']}"
                 if 'grade' in course:
                     display += f" (Grade: {course['grade']})"
                 display += "\n"
-            else:
-                display += f"- {str(course)}\n"
+            display += "\n"
     
     if 'gpa' in transcript_dict:
         gpa = transcript_dict['gpa']
@@ -447,8 +379,8 @@ def generate_response(message, history):
 with gr.Blocks() as app:
     with gr.Tab("Step 1: Upload Transcript"):
         gr.Markdown("### Upload your transcript (PDF recommended for best results)")
-        transcript_file = gr.File(label="Transcript file", file_types=[".pdf", ".csv", ".xlsx"])
-        transcript_output = gr.Textbox(label="Parsing Results")
+        transcript_file = gr.File(label="Transcript file", file_types=[".pdf"])
+        transcript_output = gr.Textbox(label="Transcript Results", lines=10)
         transcript_data = gr.State()
         transcript_file.change(
             fn=parse_transcript,
@@ -509,5 +441,5 @@ with gr.Blocks() as app:
         )
 
 if __name__ == "__main__":
-    app.launch()  
+    app.launch()