Update app.py

app.py

@@ -24,6 +24,7 @@ from functools import lru_cache
 import hashlib
 from concurrent.futures import ThreadPoolExecutor
 from pydantic import BaseModel
+import plotly.express as px
 
 # ========== CONFIGURATION ==========
 PROFILES_DIR = "student_profiles"
@@ -440,8 +441,171 @@ class TranscriptParser:
         
         raise ValueError("Could not identify course information in transcript")
 
+# ========== ENHANCED ANALYSIS FUNCTIONS ==========
+def analyze_gpa(parsed_data: Dict) -> str:
+    try:
+        gpa = float(parsed_data['student_info']['weighted_gpa'])
+        if gpa >= 4.5:
+            return "🌟 Excellent GPA! You're in the top tier of students."
+        elif gpa >= 3.5:
+            return "👍 Good GPA! You're performing above average."
+        elif gpa >= 2.5:
+            return "ℹ️ Average GPA. Consider focusing on improvement in weaker areas."
+        else:
+            return "⚠️ Below average GPA. Please consult with your academic advisor."
+    except (TypeError, ValueError, KeyError, AttributeError):
+        return "❌ Could not analyze GPA."
+
+def analyze_graduation_status(parsed_data: Dict) -> str:
+    try:
+        total_required = sum(
+            float(req['required']) 
+            for req in parsed_data['requirements'].values() 
+            if req.get('required') and str(req['required']).replace('.', '').isdigit()
+        )
+        
+        total_completed = sum(
+            float(req['completed']) 
+            for req in parsed_data['requirements'].values() 
+            if req.get('completed') and str(req['completed']).replace('.', '').isdigit()
+        )
+        
+        completion_percentage = (total_completed / total_required) * 100 if total_required > 0 else 0
+        
+        if completion_percentage >= 100:
+            return "🎉 You've met all graduation requirements!"
+        elif completion_percentage >= 80:
+            return f"✅ You've completed {completion_percentage:.1f}% of requirements. Almost there!"
+        elif completion_percentage >= 50:
+            return f"🔄 You've completed {completion_percentage:.1f}% of requirements. Keep working!"
+        else:
+            return f"⚠️ You've only completed {completion_percentage:.1f}% of requirements. Please meet with your counselor."
+    except (ZeroDivisionError, TypeError, KeyError, AttributeError):
+        return "❌ Could not analyze graduation status."
+
+def generate_advice(parsed_data: Dict) -> str:
+    advice = []
+    
+    # GPA advice
+    try:
+        gpa = float(parsed_data['student_info']['weighted_gpa'])
+        if gpa < 3.0:
+            advice.append("📚 Your GPA could improve. Consider:\n- Seeking tutoring for challenging subjects\n- Meeting with teachers during office hours\n- Developing better study habits")
+    except (TypeError, ValueError, KeyError, AttributeError):
+        pass
+    
+    # Community service advice
+    try:
+        service_hours = int(parsed_data['student_info']['community_service_hours'])
+        if service_hours < 100:
+            advice.append("🤝 Consider more community service:\n- Many colleges value 100+ hours\n- Look for opportunities that align with your interests")
+    except (TypeError, ValueError, KeyError, AttributeError):
+        pass
+    
+    # Missing requirements advice
+    try:
+        missing_reqs = [
+            req for code, req in parsed_data['requirements'].items()
+            if float(req['percent_complete']) < 100 and not code.startswith("Z-Assessment")
+        ]
+        
+        if missing_reqs:
+            req_list = "\n- ".join([f"{code}: {req['description']}" for code, req in missing_reqs])
+            advice.append(f"🎓 Focus on completing these requirements:\n- {req_list}")
+    except (TypeError, ValueError, KeyError, AttributeError):
+        pass
+    
+    # Course rigor advice
+    try:
+        ap_count = sum(1 for course in parsed_data['course_history'] if "Advanced Placement" in course['description'])
+        if ap_count < 3:
+            advice.append("🧠 Consider taking more challenging courses:\n- AP/IB courses can strengthen college applications\n- Shows academic rigor to admissions officers")
+    except (TypeError, KeyError, AttributeError):
+        pass
+    
+    return "\n\n".join(advice) if advice else "🎯 You're on track! Keep up the good work."
+
+def generate_college_recommendations(parsed_data: Dict) -> str:
+    try:
+        gpa = float(parsed_data['student_info']['weighted_gpa'])
+        ap_count = sum(1 for course in parsed_data['course_history'] if "Advanced Placement" in course['description'])
+        service_hours = int(parsed_data['student_info']['community_service_hours']) if parsed_data['student_info'].get('community_service_hours') else 0
+        
+        recommendations = []
+        
+        if gpa >= 4.0 and ap_count >= 5:
+            recommendations.append("🏛️ Reach Schools: Ivy League, Stanford, MIT, etc.")
+        if gpa >= 3.7:
+            recommendations.append("🎓 Competitive Schools: Top public universities, selective private colleges")
+        if gpa >= 3.0:
+            recommendations.append("📚 Good Match Schools: State flagship universities, many private colleges")
+        if gpa >= 2.0:
+            recommendations.append("🏫 Safety Schools: Community colleges, open admission universities")
+            
+        # Add scholarship opportunities
+        if gpa >= 3.5:
+            recommendations.append("\n💰 Scholarship Opportunities:\n- Bright Futures (Florida)\n- National Merit Scholarship\n- College-specific merit scholarships")
+        elif gpa >= 3.0:
+            recommendations.append("\n💰 Scholarship Opportunities:\n- Local community scholarships\n- Special interest scholarships\n- First-generation student programs")
+            
+        # Add extracurricular advice
+        if service_hours < 50:
+            recommendations.append("\n🎭 Extracurricular Advice:\n- Colleges value depth over breadth in activities\n- Consider leadership roles in 1-2 organizations")
+            
+        if not recommendations:
+            return "❌ Not enough data to generate college recommendations"
+            
+        return "Based on your academic profile:\n\n" + "\n\n".join(recommendations)
+    except:
+        return "❌ Could not generate college recommendations"
+
+def create_gpa_visualization(parsed_data: Dict):
+    try:
+        gpa_data = {
+            "Type": ["Weighted GPA", "Unweighted GPA"],
+            "Value": [
+                float(parsed_data['student_info']['weighted_gpa']),
+                float(parsed_data['student_info']['unweighted_gpa'])
+            ]
+        }
+        df = pd.DataFrame(gpa_data)
+        fig = px.bar(df, x="Type", y="Value", title="GPA Comparison", 
+                     color="Type", text="Value",
+                     color_discrete_sequence=["#4C78A8", "#F58518"])
+        fig.update_traces(texttemplate='%{text:.2f}', textposition='outside')
+        fig.update_layout(yaxis_range=[0,5], uniformtext_minsize=8, uniformtext_mode='hide')
+        return fig
+    except:
+        return None
+
+def create_requirements_visualization(parsed_data: Dict):
+    try:
+        req_data = []
+        for code, req in parsed_data['requirements'].items():
+            if req.get('percent_complete'):
+                completion = float(req['percent_complete'])
+                req_data.append({
+                    "Requirement": code,
+                    "Completion (%)": completion,
+                    "Status": "Complete" if completion >= 100 else "Incomplete"
+                })
+        
+        if not req_data:
+            return None
+            
+        df = pd.DataFrame(req_data)
+        fig = px.bar(df, x="Requirement", y="Completion (%)", 
+                     title="Graduation Requirements Completion",
+                     color="Status",
+                     color_discrete_map={"Complete": "#2CA02C", "Incomplete": "#D62728"},
+                     hover_data=["Requirement"])
+        fig.update_layout(xaxis={'categoryorder':'total descending'})
+        return fig
+    except:
+        return None
+
 def parse_transcript(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Dict]]:
-    """Process transcript file and return simple confirmation"""
+    """Process transcript file and return analysis results"""
     try:
         if not file_obj:
             raise gr.Error("Please upload a transcript file first (PDF or image)")
@@ -477,11 +641,35 @@ def parse_transcript(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Di
         except Exception as e:
             raise ValueError(f"Couldn't parse transcript content. Error: {str(e)}")
         
-        confirmation = "Transcript processed successfully."
-        if 'gpa' in parsed_data.get('student_info', {}):
-            confirmation += f"\nGPA detected: {parsed_data['student_info']['gpa']}"
+        # Perform enhanced analyses
+        gpa_analysis = analyze_gpa(parsed_data)
+        grad_status = analyze_graduation_status(parsed_data)
+        advice = generate_advice(parsed_data)
+        college_recs = generate_college_recommendations(parsed_data)
+        gpa_viz = create_gpa_visualization(parsed_data)
+        req_viz = create_requirements_visualization(parsed_data)
         
-        return confirmation, parsed_data
+        # Format results for display
+        results = [
+            f"📊 GPA Analysis: {gpa_analysis}",
+            f"🎓 Graduation Status: {grad_status}",
+            f"💡 Recommendations:\n{advice}",
+            f"🏫 College Recommendations:\n{college_recs}"
+        ]
+        
+        # Store all analysis results in the parsed_data
+        parsed_data['analysis'] = {
+            'gpa_analysis': gpa_analysis,
+            'grad_status': grad_status,
+            'advice': advice,
+            'college_recs': college_recs,
+            'visualizations': {
+                'gpa_viz': gpa_viz,
+                'req_viz': req_viz
+            }
+        }
+        
+        return "\n\n".join(results), parsed_data
         
     except Exception as e:
         error_msg = f"Error processing transcript: {str(e)}"
@@ -938,10 +1126,13 @@ def create_interface():
                     with gr.Column(scale=2):
                         transcript_output = gr.Textbox(
                             label="Analysis Results", 
-                            lines=5,
+                            lines=10,
                             interactive=False,
                             elem_classes="transcript-results"
                         )
+                        with gr.Row():
+                            gpa_viz = gr.Plot(label="GPA Visualization", visible=False)
+                            req_viz = gr.Plot(label="Requirements Visualization", visible=False)
                         transcript_data = gr.State()
 
                 file_input.change(
@@ -954,14 +1145,22 @@ def create_interface():
                     outputs=[file_error, transcript_output]
                 )
 
+                def process_and_visualize(file_obj, tab_status):
+                    results, data = parse_transcript(file_obj)
+                    
+                    # Update visualizations
+                    gpa_viz_update = gr.update(visible=data.get('analysis', {}).get('visualizations', {}).get('gpa_viz') is not None)
+                    req_viz_update = gr.update(visible=data.get('analysis', {}).get('visualizations', {}).get('req_viz') is not None)
+                    
+                    # Update tab completion status
+                    tab_status[0] = True
+                    
+                    return results, data, gpa_viz_update, req_viz_update, tab_status
+
                 upload_btn.click(
-                    fn=parse_transcript,
+                    fn=process_and_visualize,
                     inputs=[file_input, tab_completed],
-                    outputs=[transcript_output, transcript_data]
-                ).then(
-                    fn=lambda: {0: True},
-                    inputs=None,
-                    outputs=tab_completed
+                    outputs=[transcript_output, transcript_data, gpa_viz, req_viz, tab_completed]
                 ).then(
                     fn=lambda: gr.update(elem_classes="completed-tab"),
                     outputs=step1