Update app.py

app.py

@@ -34,6 +34,7 @@ import calendar
 from dateutil.relativedelta import relativedelta
 import numpy as np
 import matplotlib.pyplot as plt
+from tqdm import tqdm
 
 # Enhanced Configuration
 PROFILES_DIR = "student_profiles"
@@ -62,6 +63,23 @@ logger = logging.getLogger(__name__)
 # Model configuration
 MODEL_NAME = "deepseek-ai/deepseek-llm-7b"
 
+@lru_cache(maxsize=1)
+def get_model_and_tokenizer():
+    """Load and cache the model and tokenizer"""
+    logger.info("Loading model and tokenizer...")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_NAME,
+            torch_dtype=torch.float16,
+            device_map="auto"
+        )
+        logger.info("Model and tokenizer loaded successfully")
+        return model, tokenizer
+    except Exception as e:
+        logger.error(f"Failed to load model: {str(e)}")
+        raise
+
 # Initialize Hugging Face API
 if HF_TOKEN:
     hf_api = None
@@ -130,6 +148,13 @@ def validate_file(file_obj) -> None:
     if file_size > MAX_FILE_SIZE_MB:
         raise ValueError(f"File too large. Maximum size is {MAX_FILE_SIZE_MB}MB.")
 
+def validate_date(date_str: str) -> bool:
+    try:
+        datetime.datetime.strptime(date_str, '%Y-%m-%d')
+        return True
+    except ValueError:
+        return False
+
 def remove_sensitive_info(text: str) -> str:
     patterns = [
         (r'\b\d{3}-\d{2}-\d{4}\b', '[REDACTED-SSN]'),
@@ -316,20 +341,27 @@ class MiamiDadeTranscriptParser:
     def parse_transcript(self, file_path: str) -> Dict:
         """Parse Miami-Dade transcript PDF with multiple extraction methods"""
         try:
-            # First try pdfplumber
+            # First try pdfplumber with progress bar
             text = ""
             with pdfplumber.open(file_path) as pdf:
-                for page in pdf.pages:
-                    text += page.extract_text() + "\n"
+                with tqdm(total=len(pdf.pages), desc="Processing transcript") as pbar:
+                    for page in pdf.pages:
+                        text += page.extract_text() + "\n"
+                        pbar.update(1)
             
             # Fallback to PyMuPDF if text extraction is poor
             if len(text) < 500:
+                logger.warning("Low text extraction with pdfplumber, trying PyMuPDF")
                 doc = fitz.open(file_path)
                 text = ""
                 for page in doc:
                     text += page.get_text()
             
             return self._parse_miami_dade_format(text)
+        except pdfplumber.PDFSyntaxError as e:
+            error_msg = "Invalid PDF file. Please ensure you're uploading a valid transcript PDF."
+            logger.error(f"{error_msg}: {str(e)}")
+            raise ValueError(f"{error_msg} If the problem persists, try converting the file to a different format.")
         except Exception as e:
             logger.error(f"Error parsing transcript: {str(e)}")
             raise ValueError(f"Error processing transcript: {str(e)}")
@@ -636,7 +668,7 @@ class AcademicAnalyzer:
                         'remaining': max(0, info.get('required', 0) - info.get('earned', 0))
                     }
                     for subject, info in credits.items()
-                    if info and info.get('required', 0) > info.get('earned', 0))
+                    if info and info.get('required', 0) > info.get('earned', 0)
                 ]
             
             current_grade = parsed_data.get('student_info', {}).get('grade', '')
@@ -912,7 +944,7 @@ class AcademicAnalyzer:
                 study_blocks = 3
                 plan['study_strategies'].extend([
                     "Create physical models or demonstrations",
-                    "Study while walking or moving",
+                    "Study while walking or pacing",
                     "Use hands-on activities when possible"
                 ])
             
@@ -1809,6 +1841,238 @@ class EnhancedTeachingAssistant:
 # Initialize teaching assistant
 teaching_assistant = EnhancedTeachingAssistant()
 
+class StudyCalendar:
+    def __init__(self):
+        self.default_study_blocks = {
+            'Monday': [('16:00', '17:30'), ('19:00', '20:30')],
+            'Tuesday': [('16:00', '17:30')],
+            'Wednesday': [('16:00', '17:30'), ('19:00', '20:30')],
+            'Thursday': [('16:00', '17:30')],
+            'Friday': [('15:00', '16:30')],
+            'Saturday': [('10:00', '12:00')],
+            'Sunday': [('14:00', '16:00')]
+        }
+    
+    def generate_study_calendar(self, profile: Dict, start_date: str) -> Dict:
+        """Generate a study calendar based on the student's profile"""
+        try:
+            calendar = {
+                'start_date': start_date,
+                'end_date': (datetime.datetime.strptime(start_date, '%Y-%m-%d') + datetime.timedelta(days=30)).strftime('%Y-%m-%d'),
+                'events': [],
+                'exams': []
+            }
+            
+            # Add regular study sessions
+            current_date = datetime.datetime.strptime(start_date, '%Y-%m-%d')
+            end_date = datetime.datetime.strptime(calendar['end_date'], '%Y-%m-%d')
+            
+            while current_date <= end_date:
+                day_name = current_date.strftime('%A')
+                if day_name in self.default_study_blocks:
+                    for time_block in self.default_study_blocks[day_name]:
+                        calendar['events'].append({
+                            'date': current_date.strftime('%Y-%m-%d'),
+                            'title': 'Study Session',
+                            'description': 'Focused study time',
+                            'start_time': time_block[0],
+                            'end_time': time_block[1],
+                            'duration': f"{time_block[0]} to {time_block[1]}"
+                        })
+                current_date += datetime.timedelta(days=1)
+            
+            # Add exams from transcript if available
+            transcript = profile.get('transcript', {})
+            if transcript.get('course_history'):
+                for course in transcript['course_history']:
+                    if 'exam' in course.get('course_title', '').lower():
+                        exam_date = (datetime.datetime.strptime(start_date, '%Y-%m-%d') + 
+                                   datetime.timedelta(days=random.randint(7, 28))).strftime('%Y-%m-%d')
+                        calendar['exams'].append({
+                            'date': exam_date,
+                            'title': course.get('course_title', 'Exam'),
+                            'description': 'Prepare by reviewing materials',
+                            'duration': 'All day'
+                        })
+            
+            return calendar
+        except Exception as e:
+            logger.error(f"Error generating study calendar: {str(e)}")
+            return {
+                'start_date': start_date,
+                'end_date': (datetime.datetime.strptime(start_date, '%Y-%m-%d') + datetime.timedelta(days=30)).strftime('%Y-%m-%d'),
+                'events': [],
+                'exams': []
+            }
+    
+    def create_calendar_visualization(self, calendar: Dict):
+        """Create a visualization of the study calendar"""
+        try:
+            if not calendar.get('events') and not calendar.get('exams'):
+                return None
+                
+            events_df = pd.DataFrame(calendar['events'])
+            exams_df = pd.DataFrame(calendar['exams'])
+            
+            fig = px.timeline(
+                events_df, 
+                x_start="start_time", 
+                x_end="end_time", 
+                y="date",
+                color_discrete_sequence=['#4CAF50'],
+                title="Study Schedule"
+            )
+            
+            if not exams_df.empty:
+                fig.add_trace(px.timeline(
+                    exams_df,
+                    x_start=[datetime.time(0,0).strftime('%H:%M')] * len(exams_df),
+                    x_end=[datetime.time(23,59).strftime('%H:%M')] * len(exams_df),
+                    y="date",
+                    color_discrete_sequence=['#F44336']
+                ).data[0])
+            
+            fig.update_layout(
+                plot_bgcolor='rgba(0,0,0,0)',
+                paper_bgcolor='rgba(0,0,0,0)',
+                font=dict(size=12),
+                showlegend=False
+            )
+            
+            return fig
+        except Exception as e:
+            logger.error(f"Error creating calendar visualization: {str(e)}")
+            return None
+
+# Initialize study calendar
+study_calendar = StudyCalendar()
+
+class GoalTracker:
+    def __init__(self):
+        self.goals_file = Path("student_goals.json")
+        self.goals_file.touch(exist_ok=True)
+    
+    def add_goal(self, student_name: str, goal_type: str, description: str, 
+                target_date: str, target_value: Optional[float] = None) -> bool:
+        """Add a new goal for the student"""
+        try:
+            if not validate_date(target_date):
+                raise ValueError("Invalid target date format. Please use YYYY-MM-DD")
+            
+            goals = self._load_goals()
+            student_goals = goals.get(student_name, [])
+            
+            new_goal = {
+                'id': str(len(student_goals) + 1),
+                'type': goal_type,
+                'description': description,
+                'target_date': target_date,
+                'target_value': target_value,
+                'created_at': datetime.datetime.now().isoformat(),
+                'progress': []
+            }
+            
+            student_goals.append(new_goal)
+            goals[student_name] = student_goals
+            
+            with open(self.goals_file, 'w') as f:
+                json.dump(goals, f, indent=2)
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error adding goal: {str(e)}")
+            return False
+    
+    def update_goal_progress(self, student_name: str, goal_id: str, 
+                           progress_value: float, notes: str = "") -> bool:
+        """Update progress for a specific goal"""
+        try:
+            goals = self._load_goals()
+            if student_name not in goals:
+                return False
+                
+            for goal in goals[student_name]:
+                if goal['id'] == goal_id:
+                    goal['progress'].append({
+                        'date': datetime.datetime.now().isoformat(),
+                        'value': progress_value,
+                        'notes': notes
+                    })
+                    break
+            
+            with open(self.goals_file, 'w') as f:
+                json.dump(goals, f, indent=2)
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error updating goal progress: {str(e)}")
+            return False
+    
+    def get_goals(self, student_name: str) -> List[Dict]:
+        """Get all goals for a student"""
+        try:
+            goals = self._load_goals()
+            return goals.get(student_name, [])
+        except Exception as e:
+            logger.error(f"Error getting goals: {str(e)}")
+            return []
+    
+    def create_goal_visualization(self, goals: List[Dict]):
+        """Create a visualization of goal progress"""
+        try:
+            if not goals:
+                return None
+                
+            progress_data = []
+            for goal in goals:
+                if goal.get('progress'):
+                    last_progress = goal['progress'][-1]
+                    progress_data.append({
+                        'Goal': goal['description'],
+                        'Progress': last_progress['value'],
+                        'Target': goal.get('target_value', 100),
+                        'Type': goal['type']
+                    })
+            
+            if not progress_data:
+                return None
+                
+            df = pd.DataFrame(progress_data)
+            
+            fig = px.bar(
+                df,
+                x='Goal',
+                y=['Progress', 'Target'],
+                barmode='group',
+                title="Goal Progress",
+                color_discrete_map={
+                    'Progress': '#4CAF50',
+                    'Target': '#2196F3'
+                }
+            )
+            
+            fig.update_layout(
+                plot_bgcolor='rgba(0,0,0,0)',
+                paper_bgcolor='rgba(0,0,0,0)',
+                font=dict(size=12)
+            )
+            
+            return fig
+        except Exception as e:
+            logger.error(f"Error creating goal visualization: {str(e)}")
+            return None
+    
+    def _load_goals(self) -> Dict:
+        """Load all goals from the file"""
+        try:
+            with open(self.goals_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return {}
+
+# Initialize goal tracker
+goal_tracker = GoalTracker()
+
 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())
@@ -2532,7 +2796,7 @@ def create_enhanced_interface():
             outputs=None
         )
         
-        app.load(fn=lambda: model_loader.load_model(), outputs=[])
+        app.load(fn=lambda: get_model_and_tokenizer(), outputs=[])
     
     return app