Update app.py

app.py

@@ -75,7 +75,6 @@ if HF_TOKEN:
             logger.error(f"Attempt {attempt + 1} failed to initialize Hugging Face API: {str(e)}")
             time.sleep(2 ** attempt)
 
-# ========== UTILITY FUNCTIONS ==========
 class DataEncryptor:
     def __init__(self, key: str):
         self.cipher = Fernet(key.encode())
@@ -146,7 +145,6 @@ def remove_sensitive_info(text: str) -> str:
         text = re.sub(pattern, replacement, text)
     return text
 
-# ========== LEARNING STYLE QUIZ ==========
 class LearningStyleQuiz:
     def __init__(self):
         self.questions = [
@@ -252,7 +250,6 @@ class LearningStyleQuiz:
 # Initialize learning style quiz
 learning_style_quiz = LearningStyleQuiz()
 
-# ========== ENHANCED TRANSCRIPT PARSER ==========
 class EnhancedMiamiDadeTranscriptParser:
     def __init__(self):
         self.patterns = {
@@ -268,7 +265,7 @@ class EnhancedMiamiDadeTranscriptParser:
                 re.DOTALL
             ),
             'credits': re.compile(
-                r"\*\s+([A-Z\s]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s*\*",
+                r"\*\s+([A-Z\s/]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s*\*",
                 re.DOTALL
             ),
             'course': re.compile(
@@ -291,72 +288,143 @@ class EnhancedMiamiDadeTranscriptParser:
     def parse_transcript(self, file_path: str) -> Dict:
         """Parse Miami-Dade transcript PDF with enhanced pattern matching"""
         try:
+            # First try pdfplumber
             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)
+            # Fallback to PyMuPDF if text extraction is poor
+            if len(text) < 500:  # If we got very little text
+                doc = fitz.open(file_path)
+                text = ""
+                for page in doc:
+                    text += page.get_text()
+            
+            # Debug: Save extracted text
+            with open("debug_transcript.txt", "w") as f:
+                f.write(text)
                 
-                return self._parse_format(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_format(self, text: str) -> Dict:
-        """Parse the transcript format shown in the example"""
-        parsed_data = {
-            '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
+        """Parse the transcript format with improved error handling"""
+        try:
+            parsed_data = {
+                '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': 'miami_dade_v2'
+            }
+            
+            # Validate we got at least some data
+            if not parsed_data['student_info'] or not parsed_data['course_history']:
+                raise ValueError("Incomplete data extracted from transcript")
+                
+            return parsed_data
+        except Exception as e:
+            logger.error(f"Format parsing error: {str(e)}")
+            return self._parse_alternative_format(text)
+
+    def _parse_alternative_format(self, text: str) -> Dict:
+        """Fallback parser for alternative formats"""
+        try:
+            parsed_data = {
+                'student_info': {},
+                'academic_summary': {},
+                'course_history': [],
+                'assessments': {},
+                'format': 'alternative'
+            }
+            
+            # Try to extract basic student info
+            name_match = re.search(r"NAME:\s*([A-Z]+,\s*[A-Z]+)", text)
+            if name_match:
+                parsed_data['student_info']['name'] = name_match.group(1).replace(',', ' ').strip()
+                
+            # Try to extract GPA
+            gpa_match = re.search(r"GPA:\s*([\d.]+)", text)
+            if gpa_match:
+                parsed_data['academic_summary']['gpa'] = {
+                    'district': float(gpa_match.group(1)),
+                    'state': float(gpa_match.group(1))  # Assume same if not specified
+                }
+                
+            return parsed_data
+        except Exception as e:
+            logger.error(f"Alternative parser failed: {str(e)}")
+            raise ValueError("Could not parse transcript in any supported format")
 
     def _parse_student_info(self, text: str) -> Dict:
-        """Extract student information"""
+        """Extract student information with improved pattern matching"""
         match = self.patterns['student_info'].search(text)
         if not match:
-            return {}
-            
+            # Try alternative patterns
+            match = re.search(r"STUDENT INFORMATION.*?NAME:\s*([^\n]+)", text, re.DOTALL)
+            if not match:
+                return {}
+                
         return {
-            'name': match.group(1).replace(',', ' ').strip(),
-            'grade': match.group(2),
-            'student_id': match.group(3),
-            'school': match.group(4).strip(),
+            'name': match.group(1).replace(',', ' ').strip() if match else "Unknown",
+            'grade': match.group(2) if match and len(match.groups()) > 1 else "Unknown",
+            'student_id': match.group(3) if match and len(match.groups()) > 2 else "Unknown",
+            'school': match.group(4).strip() if match and len(match.groups()) > 3 else "Unknown",
             'birth_date': self._extract_birth_date(text),
             'ethnicity': self._extract_ethnicity(text)
         }
 
     def _extract_birth_date(self, text: str) -> Optional[str]:
-        """Extract birth date from transcript"""
-        birth_match = re.search(r"BIRTH DATE:\s*(\d{2}/\d{2}/\d{4})", text)
-        return birth_match.group(1) if birth_match else None
+        """Extract birth date from transcript with multiple pattern attempts"""
+        patterns = [
+            r"BIRTH DATE:\s*(\d{2}/\d{2}/\d{4})",
+            r"DOB:\s*(\d{2}/\d{2}/\d{4})",
+            r"DATE OF BIRTH:\s*([^\n]+)"
+        ]
+        
+        for pattern in patterns:
+            birth_match = re.search(pattern, text)
+            if birth_match:
+                return birth_match.group(1)
+        return None
 
     def _extract_ethnicity(self, text: str) -> Optional[str]:
-        """Extract ethnicity information"""
-        eth_match = re.search(r"ETHNICITY:\s*([^\n]+)", text)
-        return eth_match.group(1).strip() if eth_match else None
+        """Extract ethnicity information with multiple pattern attempts"""
+        patterns = [
+            r"ETHNICITY:\s*([^\n]+)",
+            r"RACE/ETHNICITY:\s*([^\n]+)",
+            r"DEMOGRAPHICS.*?ETHNICITY:\s*([^\n]+)"
+        ]
+        
+        for pattern in patterns:
+            eth_match = re.search(pattern, text, re.DOTALL)
+            if eth_match:
+                return eth_match.group(1).strip()
+        return None
 
     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)
-        
+        """Parse academic summary section with improved error handling"""
         summary = {
-            'gpa': {
-                'district': float(gpa_match.group(1)) if gpa_match else None,
-                'state': float(gpa_match.group(2)) if gpa_match else None
-            },
+            'gpa': {'district': None, 'state': None},
             'credits': {},
-            '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
-            }
+            'class_rank': {'percentile': None, 'class_size': None}
         }
         
+        # Try multiple GPA patterns
+        gpa_match = self.patterns['gpa'].search(text)
+        if not gpa_match:
+            gpa_match = re.search(r"GPA.*?([\d.]+).*?([\d.]+)", text)
+            
+        if gpa_match:
+            summary['gpa']['district'] = float(gpa_match.group(1))
+            summary['gpa']['state'] = float(gpa_match.group(2)) if gpa_match.group(2) else summary['gpa']['district']
+        
+        # Try multiple credit patterns
+        credits_matches = self.patterns['credits'].finditer(text)
+        if not credits_matches:
+            credits_matches = re.finditer(r"([A-Z ]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)", text)
+            
         for match in credits_matches:
             subject = match.group(1).strip()
             summary['credits'][subject] = {
@@ -365,28 +433,60 @@ class EnhancedMiamiDadeTranscriptParser:
                 'remaining': float(match.group(4)) if match.group(4) else None
             }
             
+        # Try multiple class rank patterns
+        rank_match = self.patterns['class_rank'].search(text)
+        if not rank_match:
+            rank_match = re.search(r"RANK.*?(\d+).*?(\d+)", text)
+            
+        if rank_match:
+            summary['class_rank']['percentile'] = int(rank_match.group(1))
+            summary['class_rank']['class_size'] = int(rank_match.group(2))
+            
         return summary
 
     def _parse_courses(self, text: str) -> List[Dict]:
-        """Parse course history section"""
+        """Parse course history section with improved pattern matching"""
         courses = []
+        
+        # Try primary pattern first
         for match in self.patterns['course'].finditer(text):
-            courses.append({
-                'term': match.group(1),
-                'course_code': match.group(2),
-                'course_title': match.group(3).strip(),
-                'subject_area': match.group(4),
-                'grade': match.group(5),
-                'flag': match.group(6),
-                'credit_status': match.group(7),
-                'credit_attempted': float(match.group(8)),
-                'credit_earned': float(match.group(9))
-            })
+            courses.append(self._create_course_dict(match))
+            
+        # If no courses found, try alternative patterns
+        if not courses:
+            alt_pattern = re.compile(
+                r"(\d{4}-\d{4})\s+(\w+)\s+([^\n]+?)\s+([A-Z]{2})\s+([A-Z])\s+([\d.]+)",
+                re.DOTALL
+            )
+            for match in alt_pattern.finditer(text):
+                courses.append({
+                    'term': match.group(1),
+                    'course_code': match.group(2),
+                    'course_title': match.group(3).strip(),
+                    'subject_area': match.group(4),
+                    'grade': match.group(5),
+                    'credit_earned': float(match.group(6)),
+                    'credit_attempted': float(match.group(6))
+                })
+                
         return courses
 
+    def _create_course_dict(self, match) -> Dict:
+        """Create standardized course dictionary from regex match"""
+        return {
+            'term': match.group(1),
+            'course_code': match.group(2),
+            'course_title': match.group(3).strip(),
+            'subject_area': match.group(4),
+            'grade': match.group(5),
+            'flag': match.group(6),
+            'credit_status': match.group(7),
+            'credit_attempted': float(match.group(8)),
+            'credit_earned': float(match.group(9))
+        }
+
     def _parse_assessments(self, text: str) -> Dict:
-        """Parse assessment and requirement information"""
-        matches = self.patterns['assessment'].finditer(text)
+        """Parse assessment and requirement information with improved patterns"""
         assessments = {
             'ela_passed_date': None,
             'algebra_passed': False,
@@ -397,17 +497,22 @@ class EnhancedMiamiDadeTranscriptParser:
             }
         }
         
+        # Try multiple assessment patterns
+        matches = self.patterns['assessment'].finditer(text)
+        if not matches:
+            matches = re.finditer(r"(ENGLISH|ALGEBRA|BIOLOGY|SERVICE).*?(PASSED|MET|YES|NO|\d{2}/\d{4})", text)
+            
         for match in matches:
             if match.group(1):  # ELA date
                 assessments['ela_passed_date'] = match.group(1)
             elif match.group(2):  # Algebra
                 assessments['algebra_passed'] = match.group(2) == "YES"
-            elif "BIOLOGY ASSESSMENT PASSED" in match.group(0):
+            elif "BIOLOGY" in match.group(0):
                 assessments['biology_passed'] = True
-            elif match.group(3):  # Community service
+            elif "SERVICE" in match.group(0):
                 assessments['community_service'] = {
                     'met': True,
-                    'hours': int(match.group(4))
+                    'hours': int(match.group(4)) if match.group(4) else 0
                 }
                 
         return assessments
@@ -415,7 +520,6 @@ class EnhancedMiamiDadeTranscriptParser:
 # Initialize the enhanced parser
 transcript_parser = EnhancedMiamiDadeTranscriptParser()
 
-# ========== ACADEMIC ANALYZER ==========
 class AcademicAnalyzer:
     def __init__(self):
         self.gpa_scale = {
@@ -439,12 +543,16 @@ class AcademicAnalyzer:
         }
         
         try:
+            # Handle multiple transcript formats
             if parsed_data.get('format') == 'progress_summary':
                 weighted_gpa = float(parsed_data.get('student_info', {}).get('weighted_gpa', 0))
                 unweighted_gpa = float(parsed_data.get('student_info', {}).get('unweighted_gpa', 0))
-            else:
+            elif parsed_data.get('format') == 'miami_dade_v2':
                 weighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('district', 0))
                 unweighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', {}).get('state', 0))
+            else:  # Alternative format
+                weighted_gpa = float(parsed_data.get('academic_summary', {}).get('gpa', 0))
+                unweighted_gpa = weighted_gpa  # Assume same if not specified
             
             if weighted_gpa >= 4.5:
                 analysis['rating'] = 'Excellent'
@@ -502,12 +610,16 @@ class AcademicAnalyzer:
                     analysis['comparison'] += "\n\nThe small difference between your weighted and unweighted GPA suggests you might benefit from more challenging courses."
             
             return analysis
-        except:
+        except Exception as e:
+            logger.error(f"GPA analysis error: {str(e)}")
             return {
                 'rating': 'Unknown',
-                'description': 'Could not analyze GPA',
-                'comparison': '',
-                'improvement_tips': []
+                'description': 'Could not analyze GPA - data may be missing or incomplete',
+                'comparison': 'Please verify your transcript contains GPA information',
+                'improvement_tips': [
+                    "Check that your transcript includes GPA information",
+                    "Ensure the file is clear and all text was extracted properly"
+                ]
             }
     
     def analyze_graduation_status(self, parsed_data: Dict) -> Dict:
@@ -603,13 +715,14 @@ class AcademicAnalyzer:
                     )
             
             return analysis
-        except:
+        except Exception as e:
+            logger.error(f"Graduation status error: {str(e)}")
             return {
-                'status': 'Could not analyze graduation status',
+                'status': 'Could not analyze graduation status - data may be incomplete',
                 'completion_percentage': 0,
                 'missing_requirements': [],
                 'on_track': False,
-                'timeline': ''
+                'timeline': 'Please verify your transcript contains credit information'
             }
     
     def analyze_course_rigor(self, parsed_data: Dict) -> Dict:
@@ -678,7 +791,8 @@ class AcademicAnalyzer:
                 ]
             
             return analysis
-        except:
+        except Exception as e:
+            logger.error(f"Course rigor error: {str(e)}")
             return {
                 'advanced_courses': 0,
                 'honors_courses': 0,
@@ -686,7 +800,10 @@ class AcademicAnalyzer:
                 'ib_courses': 0,
                 'de_courses': 0,
                 'rating': 'Unknown',
-                'recommendations': []
+                'recommendations': [
+                    "Could not analyze course rigor - verify your transcript contains course information",
+                    "Check that course titles and types were properly extracted"
+                ]
             }
     
     def generate_college_recommendations(self, parsed_data: Dict) -> Dict:
@@ -782,13 +899,17 @@ class AcademicAnalyzer:
                 recommendations['improvement_areas'].append("Increase community service involvement")
             
             return recommendations
-        except:
+        except Exception as e:
+            logger.error(f"College recommendations error: {str(e)}")
             return {
-                'reach': ["Could not generate recommendations"],
+                'reach': ["Could not generate recommendations - insufficient data"],
                 'target': [],
                 'safety': [],
                 'scholarships': [],
-                'improvement_areas': []
+                'improvement_areas': [
+                    "Complete your profile information",
+                    "Ensure your transcript contains GPA and course information"
+                ]
             }
     
     def generate_study_plan(self, parsed_data: Dict, learning_style: str) -> Dict:
@@ -867,18 +988,30 @@ class AcademicAnalyzer:
             ])
             
             return plan
-        except:
+        except Exception as e:
+            logger.error(f"Study plan error: {str(e)}")
             return {
-                'weekly_schedule': {'Error': ["Could not generate schedule"]},
-                'study_strategies': [],
-                'time_management_tips': [],
-                'resource_recommendations': []
+                'weekly_schedule': {'Error': ["Could not generate schedule - course data may be missing"]},
+                'study_strategies': [
+                    "Review your notes regularly",
+                    "Create a consistent study routine",
+                    "Ask teachers for clarification when needed"
+                ],
+                'time_management_tips': [
+                    "Set aside dedicated study time each day",
+                    "Break large tasks into smaller chunks",
+                    "Use a planner to track assignments"
+                ],
+                'resource_recommendations': [
+                    "Khan Academy",
+                    "Quizlet",
+                    "Your textbook and class materials"
+                ]
             }
 
 # Initialize academic analyzer
 academic_analyzer = AcademicAnalyzer()
 
-# ========== DATA VISUALIZER ==========
 class DataVisualizer:
     def __init__(self):
         self.color_palette = {
@@ -1146,7 +1279,6 @@ class DataVisualizer:
 # Initialize visualizer
 data_visualizer = DataVisualizer()
 
-# ========== PROFILE MANAGER ==========
 class EnhancedProfileManager:
     def __init__(self):
         self.profiles_dir = Path(PROFILES_DIR)
@@ -1353,7 +1485,6 @@ class EnhancedProfileManager:
 # Initialize profile manager
 profile_manager = EnhancedProfileManager()
 
-# ========== TEACHING ASSISTANT ==========
 class EnhancedTeachingAssistant:
     def __init__(self):
         self.context_history = []
@@ -1723,7 +1854,6 @@ class EnhancedTeachingAssistant:
 # Initialize teaching assistant
 teaching_assistant = EnhancedTeachingAssistant()
 
-# ========== GRADIO INTERFACE ==========
 def create_enhanced_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Student Learning Assistant") as app:
         session_token = gr.State(value=generate_session_token())
@@ -2454,5 +2584,4 @@ def create_enhanced_interface():
 app = create_enhanced_interface()
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
-    
+    app.launch(server_name="0.0.0.0", server_port=7860)