fixing login bug

components/dashboard_page.py

@@ -152,54 +152,54 @@ class DashboardPage:
             if not user_id:
                 return "Annotation Progress: N/A" # Added label
             with get_db() as db:
-                try:
-                    # Total items assigned to the user
-                    total_assigned_query = db.query(func.sum(AnnotationInterval.end_index - AnnotationInterval.start_index + 1)).filter(AnnotationInterval.annotator_id == user_id)
-                    total_assigned_result = total_assigned_query.scalar()
-                    total_assigned = total_assigned_result if total_assigned_result is not None else 0
-                    
-                    # Count of non-empty annotations by this user within their assigned intervals
-                    completed_count_query = db.query(func.count(Annotation.id)).join(
-                        TTSData, Annotation.tts_data_id == TTSData.id
-                    ).join(
-                        AnnotationInterval,
-                        (AnnotationInterval.annotator_id == user_id) &
-                        (TTSData.id >= AnnotationInterval.start_index) &
-                        (TTSData.id <= AnnotationInterval.end_index)
-                    ).filter(
-                        Annotation.annotator_id == user_id,
-                        Annotation.annotated_sentence != None,
-                        Annotation.annotated_sentence != ""
-                    )
-                    completed_count_result = completed_count_query.scalar()
-                    completed_count = completed_count_result if completed_count_result is not None else 0
-                    
-                    if total_assigned > 0:
-                        percent = (completed_count / total_assigned) * 100
-                        bar_length = 20 # Length of the progress bar
-                        filled_length = int(bar_length * completed_count // total_assigned)
-                        bar = '█' * filled_length + '░' * (bar_length - filled_length)
-                        return f"Progress: {bar} {completed_count}/{total_assigned} ({percent:.1f}%)"
-                    elif total_assigned == 0 and completed_count == 0: # Handles case where user has 0 assigned items initially
-                        return "Progress: No items assigned yet."
-                    else: # Should ideally not happen if logic is correct (e.g. completed > total_assigned)
-                        return f"Annotation Progress: {completed_count}/{total_assigned} labeled"
-                except Exception as e:
-                    log.error(f"Error fetching progress for user {user_id}: {e}") 
-                    sentry_sdk.capture_exception(e)
-                    raise
+                # try:
+                # Total items assigned to the user
+                total_assigned_query = db.query(func.sum(AnnotationInterval.end_index - AnnotationInterval.start_index + 1)).filter(AnnotationInterval.annotator_id == user_id)
+                total_assigned_result = total_assigned_query.scalar()
+                total_assigned = total_assigned_result if total_assigned_result is not None else 0
+                
+                # Count of non-empty annotations by this user within their assigned intervals
+                completed_count_query = db.query(func.count(Annotation.id)).join(
+                    TTSData, Annotation.tts_data_id == TTSData.id
+                ).join(
+                    AnnotationInterval,
+                    (AnnotationInterval.annotator_id == user_id) &
+                    (TTSData.id >= AnnotationInterval.start_index) &
+                    (TTSData.id <= AnnotationInterval.end_index)
+                ).filter(
+                    Annotation.annotator_id == user_id,
+                    Annotation.annotated_sentence != None,
+                    Annotation.annotated_sentence != ""
+                )
+                completed_count_result = completed_count_query.scalar()
+                completed_count = completed_count_result if completed_count_result is not None else 0
+                
+                if total_assigned > 0:
+                    percent = (completed_count / total_assigned) * 100
+                    bar_length = 20 # Length of the progress bar
+                    filled_length = int(bar_length * completed_count // total_assigned)
+                    bar = '█' * filled_length + '░' * (bar_length - filled_length)
+                    return f"Progress: {bar} {completed_count}/{total_assigned} ({percent:.1f}%)"
+                elif total_assigned == 0 and completed_count == 0: # Handles case where user has 0 assigned items initially
+                    return "Progress: No items assigned yet."
+                else: # Should ideally not happen if logic is correct (e.g. completed > total_assigned)
+                    return f"Annotation Progress: {completed_count}/{total_assigned} labeled"
+                # except Exception as e:
+                #     log.error(f"Error fetching progress for user {user_id}: {e}") 
+                #     sentry_sdk.capture_exception(e)
+                #     raise
 
         def download_voice_fn(filename_to_load, autoplay_on_load=True): # Autoplay here is for the btn_load_voice click
             if not filename_to_load:
                 return None, None, gr.update(value=None, autoplay=False)
-            try:
-                log.info(f"Downloading voice: {filename_to_load}, Autoplay: {autoplay_on_load}")
-                sr, wav = LOADER.load_audio(filename_to_load)
-                return (sr, wav), (sr, wav.copy()), gr.update(value=(sr, wav), autoplay=autoplay_on_load)
-            except Exception as e:
-                log.error(f"GDrive download failed for {filename_to_load}: {e}") 
-                sentry_sdk.capture_exception(e)
-                raise
+            # try:
+            log.info(f"Downloading voice: {filename_to_load}, Autoplay: {autoplay_on_load}")
+            sr, wav = LOADER.load_audio(filename_to_load)
+            return (sr, wav), (sr, wav.copy()), gr.update(value=(sr, wav), autoplay=autoplay_on_load)
+            # except Exception as e:
+            #     log.error(f"GDrive download failed for {filename_to_load}: {e}") 
+            #     sentry_sdk.capture_exception(e)
+            #     raise
         
         def save_annotation_db_fn(current_tts_id, session, ann_text_to_save, applied_trims_list):
             annotator_id = session.get("user_id")
@@ -208,62 +208,62 @@ class DashboardPage:
                 return # Modified: No return value
             
             with get_db() as db:
-                try:
-                    annotation_obj = db.query(Annotation).filter_by(
-                        tts_data_id=current_tts_id, annotator_id=annotator_id
-                    ).options(orm.joinedload(Annotation.audio_trims)).first()
+                # try:
+                annotation_obj = db.query(Annotation).filter_by(
+                    tts_data_id=current_tts_id, annotator_id=annotator_id
+                ).options(orm.joinedload(Annotation.audio_trims)).first()
 
-                    if not annotation_obj:
-                        annotation_obj = Annotation(
-                            tts_data_id=current_tts_id, annotator_id=annotator_id
+                if not annotation_obj:
+                    annotation_obj = Annotation(
+                        tts_data_id=current_tts_id, annotator_id=annotator_id
+                    )
+                    db.add(annotation_obj)
+                
+                annotation_obj.annotated_sentence = ann_text_to_save
+                annotation_obj.annotated_at = datetime.datetime.utcnow()
+
+                # --- Multi-trim handling --- 
+                # 1. Delete existing trims for this annotation
+                if annotation_obj.audio_trims:
+                    for old_trim in annotation_obj.audio_trims:
+                        db.delete(old_trim)
+                    annotation_obj.audio_trims = [] # Clear the collection
+                    # db.flush() # Ensure deletes are processed before adds if issues arise
+
+                # 2. Add new trims from applied_trims_list
+                if applied_trims_list:
+                    if annotation_obj.id is None: # If new annotation, flush to get ID
+                        db.flush()
+                    if annotation_obj.id is None:
+                        gr.Error("Failed to get annotation ID for saving new trims.")
+                        db.rollback(); return # Modified: No return value
+                        
+                    for trim_info in applied_trims_list:
+                        start_to_save_ms = trim_info['start_sec'] * 1000.0
+                        end_to_save_ms = trim_info['end_sec'] * 1000.0
+                        original_data_id_for_trim = current_tts_id
+
+                        new_trim_db_obj = AudioTrim(
+                            annotation_id=annotation_obj.id,
+                            original_tts_data_id=original_data_id_for_trim, 
+                            start=start_to_save_ms, 
+                            end=end_to_save_ms,
                         )
-                        db.add(annotation_obj)
-                    
-                    annotation_obj.annotated_sentence = ann_text_to_save
-                    annotation_obj.annotated_at = datetime.datetime.utcnow()
-
-                    # --- Multi-trim handling --- 
-                    # 1. Delete existing trims for this annotation
-                    if annotation_obj.audio_trims:
-                        for old_trim in annotation_obj.audio_trims:
-                            db.delete(old_trim)
-                        annotation_obj.audio_trims = [] # Clear the collection
-                        # db.flush() # Ensure deletes are processed before adds if issues arise
-
-                    # 2. Add new trims from applied_trims_list
-                    if applied_trims_list:
-                        if annotation_obj.id is None: # If new annotation, flush to get ID
-                            db.flush()
-                        if annotation_obj.id is None:
-                            gr.Error("Failed to get annotation ID for saving new trims.")
-                            db.rollback(); return # Modified: No return value
-                            
-                        for trim_info in applied_trims_list:
-                            start_to_save_ms = trim_info['start_sec'] * 1000.0
-                            end_to_save_ms = trim_info['end_sec'] * 1000.0
-                            original_data_id_for_trim = current_tts_id
-
-                            new_trim_db_obj = AudioTrim(
-                                annotation_id=annotation_obj.id,
-                                original_tts_data_id=original_data_id_for_trim, 
-                                start=start_to_save_ms, 
-                                end=end_to_save_ms,
-                            )
-                            db.add(new_trim_db_obj)
-                            # No need to append to annotation_obj.audio_trims if cascade is working correctly
-                            # but can be done explicitly: annotation_obj.audio_trims.append(new_trim_db_obj)
-                        log.info(f"Saved {len(applied_trims_list)} trims for annotation {annotation_obj.id} (TTS ID: {current_tts_id}).")
-                    else:
-                        log.info(f"No trims applied for {current_tts_id}, any existing DB trims were cleared.")
-                    
-                    db.commit()
-                    gr.Info(f"Annotation for ID {current_tts_id} saved.")
-                    # Removed 'return True'
-                except Exception as e:
-                    db.rollback()
-                    log.error(f"Failed to save annotation for {current_tts_id}: {e}") # Removed exc_info=True
-                    sentry_sdk.capture_exception(e)
-                    raise
+                        db.add(new_trim_db_obj)
+                        # No need to append to annotation_obj.audio_trims if cascade is working correctly
+                        # but can be done explicitly: annotation_obj.audio_trims.append(new_trim_db_obj)
+                    log.info(f"Saved {len(applied_trims_list)} trims for annotation {annotation_obj.id} (TTS ID: {current_tts_id}).")
+                else:
+                    log.info(f"No trims applied for {current_tts_id}, any existing DB trims were cleared.")
+                
+                db.commit()
+                gr.Info(f"Annotation for ID {current_tts_id} saved.")
+                # Removed 'return True'
+                # except Exception as e:
+                #     db.rollback()
+                #     log.error(f"Failed to save annotation for {current_tts_id}: {e}") # Removed exc_info=True
+                #     sentry_sdk.capture_exception(e)
+                #     raise
 
         def show_current_item_fn(items, idx, session):
             initial_trims_list_sec = []
@@ -283,25 +283,25 @@ class DashboardPage:
 
             if tts_data_id and annotator_id:
                 with get_db() as db:
-                    try:
-                        existing_annotation = db.query(Annotation).filter_by(
-                            tts_data_id=tts_data_id, annotator_id=annotator_id
-                        ).options(orm.joinedload(Annotation.audio_trims)).first() # Changed to audio_trims
-                        if existing_annotation:
-                            ann_text = existing_annotation.annotated_sentence or ""
-                            if existing_annotation.audio_trims: # Check the collection
-                                initial_trims_list_sec = [
-                                    {
-                                        'start_sec': trim.start / 1000.0,
-                                        'end_sec': trim.end / 1000.0
-                                    }
-                                    for trim in existing_annotation.audio_trims # Iterate over the collection
-                                ]
-                                initial_trims_df_data = self._convert_trims_to_df_data(initial_trims_list_sec)
-                    except Exception as e:
-                        log.error(f"DB error in show_current_item_fn for TTS ID {tts_data_id}: {e}") # Removed exc_info=True
-                        sentry_sdk.capture_exception(e)
-                        raise
+                    # try:
+                    existing_annotation = db.query(Annotation).filter_by(
+                        tts_data_id=tts_data_id, annotator_id=annotator_id
+                    ).options(orm.joinedload(Annotation.audio_trims)).first() # Changed to audio_trims
+                    if existing_annotation:
+                        ann_text = existing_annotation.annotated_sentence or ""
+                        if existing_annotation.audio_trims: # Check the collection
+                            initial_trims_list_sec = [
+                                {
+                                    'start_sec': trim.start / 1000.0,
+                                    'end_sec': trim.end / 1000.0
+                                }
+                                for trim in existing_annotation.audio_trims # Iterate over the collection
+                            ]
+                            initial_trims_df_data = self._convert_trims_to_df_data(initial_trims_list_sec)
+                    # except Exception as e:
+                    #     log.error(f"DB error in show_current_item_fn for TTS ID {tts_data_id}: {e}") # Removed exc_info=True
+                    #     sentry_sdk.capture_exception(e)
+                    #     raise
             
             return (
                 current_item.get("id", ""), current_item.get("filename", ""),
@@ -320,54 +320,56 @@ class DashboardPage:
 
         def load_all_items_fn(sess):
             user_id = sess.get("user_id") # Use user_id for consistency with other functions
-            user_name = sess.get("user_name") # Keep for logging if needed
+            user_name = sess.get("username") # Changed from "user_name" to "username" to match session key
             items_to_load = []
             initial_idx = 0 # Default to 0
 
             if not user_id:
-                log.warning("load_all_items_fn: user_id not found in session. Dashboard will display default state until login completes and data is refreshed.")
+                # No user logged in - return empty state without warning
+                # This is normal on initial app load before login
+                log.info("load_all_items_fn: user_id not found in session. Dashboard will display default state until login completes and data is refreshed.")
                 empty_item_display_tuple = ("", "", "", "", None, None, None, [], self._convert_trims_to_df_data([]), gr.update(value=None, autoplay=False))
-                return [[], 0] + list(empty_item_display_tuple) + ["Progress: loading data..."]
+                return [[], 0] + list(empty_item_display_tuple) + [""]
 
             if user_id:
                 with get_db() as db:
-                    try:
-                        repo = AnnotatorWorkloadRepo(db)
-                        raw_items = repo.get_tts_data_with_annotations_for_user_id(user_id, annotator_name_for_log=user_name) 
+                    # try:
+                    repo = AnnotatorWorkloadRepo(db)
+                    raw_items = repo.get_tts_data_with_annotations_for_user_id(user_id, annotator_name_for_log=user_name) 
+                    
+                    items_to_load = [
+                        {
+                            "id": item["tts_data"].id,
+                            "filename": item["tts_data"].filename,
+                            "sentence": item["tts_data"].sentence,
+                            "annotated": item["annotation"] is not None and (item["annotation"].annotated_sentence is not None and item["annotation"].annotated_sentence != "")
+                        }
+                        for item in raw_items
+                    ]
+                    log.info(f"Loaded {len(items_to_load)} items for user {user_name} (ID: {user_id})")
+
+                    # --- Resume Logic: Find first unannotated or last item ---
+                    if items_to_load:
+                        first_unannotated_idx = -1
+                        for i, item_data in enumerate(items_to_load):
+                            if not item_data["annotated"]:
+                                first_unannotated_idx = i
+                                break
                         
-                        items_to_load = [
-                            {
-                                "id": item["tts_data"].id,
-                                "filename": item["tts_data"].filename,
-                                "sentence": item["tts_data"].sentence,
-                                "annotated": item["annotation"] is not None and (item["annotation"].annotated_sentence is not None and item["annotation"].annotated_sentence != "")
-                            }
-                            for item in raw_items
-                        ]
-                        log.info(f"Loaded {len(items_to_load)} items for user {user_name} (ID: {user_id})")
-
-                        # --- Resume Logic: Find first unannotated or last item ---
-                        if items_to_load:
-                            first_unannotated_idx = -1
-                            for i, item_data in enumerate(items_to_load):
-                                if not item_data["annotated"]:
-                                    first_unannotated_idx = i
-                                    break
-                            
-                            if first_unannotated_idx != -1:
-                                initial_idx = first_unannotated_idx
-                                log.info(f"Resuming at first unannotated item, index: {initial_idx} (ID: {items_to_load[initial_idx]['id']})")
-                            else: # All items are annotated
-                                initial_idx = len(items_to_load) - 1
-                                log.info(f"All items annotated, starting at last item, index: {initial_idx} (ID: {items_to_load[initial_idx]['id']})")
-                        else: # No items assigned
-                            initial_idx = 0
-                            log.info("No items assigned to user, starting at index 0.")
-
-                    except Exception as e:
-                        log.error(f"Failed to load items or determine resume index for user {user_name}: {e}")
-                        sentry_sdk.capture_exception(e)
-                        raise
+                        if first_unannotated_idx != -1:
+                            initial_idx = first_unannotated_idx
+                            log.info(f"Resuming at first unannotated item, index: {initial_idx} (ID: {items_to_load[initial_idx]['id']})")
+                        else: # All items are annotated
+                            initial_idx = len(items_to_load) - 1
+                            log.info(f"All items annotated, starting at last item, index: {initial_idx} (ID: {items_to_load[initial_idx]['id']})")
+                    else: # No items assigned
+                        initial_idx = 0
+                        log.info("No items assigned to user, starting at index 0.")
+
+                    # except Exception as e:
+                    #     log.error(f"Failed to load items or determine resume index for user {user_name}: {e}")
+                    #     sentry_sdk.capture_exception(e)
+                    #     raise
             
             initial_ui_values_tuple = show_current_item_fn(items_to_load, initial_idx, sess)
             progress_str = get_user_progress_fn(sess)
@@ -375,28 +377,17 @@ class DashboardPage:
         
         def jump_by_data_id_fn(items, target_data_id_str, current_idx):
             if not target_data_id_str: return current_idx
-            try:
-                target_id = int(target_data_id_str)
-                for i, item_dict in enumerate(items):
-                    if item_dict.get("id") == target_id: return i
-                gr.Warning(f"Data ID {target_id} not found in your assigned items.")
-            except ValueError:
-                sentry_sdk.capture_exception()
-                gr.Warning(f"Invalid Data ID format: {target_data_id_str}")
+            # try:
+            target_id = int(target_data_id_str)
+            for i, item_dict in enumerate(items):
+                if item_dict.get("id") == target_id: return i
+            gr.Warning(f"Data ID {target_id} not found in your assigned items.")
+            # except ValueError:
+            #     sentry_sdk.capture_exception()
+            #     gr.Warning(f"Invalid Data ID format: {target_data_id_str}")
             return current_idx
 
         def delete_db_and_ui_fn(items, current_idx, session, original_audio_data_state):
-            # ... (ensure Annotation.audio_trims is used if deleting associated trims) ...
-            # This function already deletes annotation_obj.audio_trim, which will now be annotation_obj.audio_trims
-            # The cascade delete on the relationship should handle deleting all AudioTrim children.
-            # However, explicit deletion loop might be safer if cascade behavior is not fully trusted or for clarity.
-            # For now, relying on cascade from previous model update.
-            # If issues, add explicit loop:
-            # if annotation_obj.audio_trims:
-            #     for trim_to_del in annotation_obj.audio_trims:
-            #         db.delete(trim_to_del)
-            #     annotation_obj.audio_trims = []
-            # ... rest of the function ...
             new_ann_sentence = ""
             new_trim_start_sec_ui = None # Changed from 0.0
             new_trim_end_sec_ui = None # Changed from 0.0
@@ -426,28 +417,21 @@ class DashboardPage:
 
             if tts_data_id_to_clear and annotator_id_for_clear:
                 with get_db() as db:
-                    try:
-                        annotation_obj = db.query(Annotation).filter_by(
-                            tts_data_id=tts_data_id_to_clear, annotator_id=annotator_id_for_clear
-                        ).options(orm.joinedload(Annotation.audio_trims)).first() # Ensure audio_trims are loaded
-                        if annotation_obj:
-                            # Cascade delete should handle deleting AudioTrim objects associated with this annotation
-                            # If not, uncomment and adapt the loop below:
-                            # if annotation_obj.audio_trims:
-                            #     log.info(f"Deleting {len(annotation_obj.audio_trims)} trims for annotation ID {annotation_obj.id}")
-                            #     for trim_to_delete in list(annotation_obj.audio_trims): # Iterate over a copy
-                            #         db.delete(trim_to_delete)
-                            #     annotation_obj.audio_trims = [] # Clear the collection
-                            db.delete(annotation_obj)
-                            db.commit()
-                            gr.Info(f"Annotation and associated trims for ID {tts_data_id_to_clear} deleted from DB.")
-                        else:
-                            gr.Warning(f"No DB annotation found to delete for ID {tts_data_id_to_clear}.")
-                    except Exception as e:
-                        db.rollback()
-                        log.error(f"Error deleting annotation from DB for {tts_data_id_to_clear}: {e}") # Removed exc_info=True
-                        sentry_sdk.capture_exception(e)
-                        raise
+                    # try:
+                    annotation_obj = db.query(Annotation).filter_by(
+                        tts_data_id=tts_data_id_to_clear, annotator_id=annotator_id_for_clear
+                    ).options(orm.joinedload(Annotation.audio_trims)).first() # Ensure audio_trims are loaded
+                    if annotation_obj:
+                        db.delete(annotation_obj)
+                        db.commit()
+                        gr.Info(f"Annotation and associated trims for ID {tts_data_id_to_clear} deleted from DB.")
+                    else:
+                        gr.Warning(f"No DB annotation found to delete for ID {tts_data_id_to_clear}.")
+                    # except Exception as e:
+                    #     db.rollback()
+                    #     log.error(f"Error deleting annotation from DB for {tts_data_id_to_clear}: {e}") # Removed exc_info=True
+                    #     sentry_sdk.capture_exception(e)
+                    #     raise
             else:
                  gr.Error("Cannot clear/delete annotation from DB: Missing TTS ID or User ID.")
 

components/review_dashboard_page.py

@@ -120,36 +120,36 @@ class ReviewDashboardPage:
         def download_voice_fn(filename_to_load):
             if not filename_to_load:
                 return None, None, gr.update(value=None, autoplay=False)
-            try:
-                log.info(f"Downloading voice for review: {filename_to_load}")
-                # Show progress to user
-                # gr.Info(f"Loading audio file: {filename_to_load}")
-                
-                sr, wav = LOADER.load_audio(filename_to_load)
-                
-                log.info(f"Successfully loaded audio: {filename_to_load} (SR: {sr}, Length: {len(wav)} samples)")
-                # gr.Info(f"✅ Audio loaded successfully!")
-                
-                return (sr, wav), (sr, wav.copy()), gr.update(value=(sr, wav), autoplay=True)
-            except TimeoutError as e:
-                log.error(f"Audio download timeout for {filename_to_load}: {e}")
-                sentry_sdk.capture_exception(e)
-                raise
-            except ConnectionError as e:
-                log.error(f"Audio download connection error for {filename_to_load}: {e}")
-                sentry_sdk.capture_exception(e)
-                gr.Error(f"🌐 Connection error loading audio: {filename_to_load}. Please check your internet connection.")
-                return None, None, gr.update(value=None, autoplay=False)
-            except FileNotFoundError as e:
-                log.error(f"Audio file not found for {filename_to_load}: {e}")
-                sentry_sdk.capture_exception(e)
-                gr.Error(f"📁 Audio file not found: {filename_to_load}")
-                return None, None, gr.update(value=None, autoplay=False)
-            except Exception as e:
-                log.error(f"Audio download failed for {filename_to_load}: {e}")
-                sentry_sdk.capture_exception(e)
-                gr.Error(f"❌ Failed to load audio: {filename_to_load}. Error: {e}")
-                return None, None, gr.update(value=None, autoplay=False)
+            # try:
+            log.info(f"Downloading voice for review: {filename_to_load}")
+            # Show progress to user
+            # gr.Info(f"Loading audio file: {filename_to_load}")
+            
+            sr, wav = LOADER.load_audio(filename_to_load)
+            
+            log.info(f"Successfully loaded audio: {filename_to_load} (SR: {sr}, Length: {len(wav)} samples)")
+            # gr.Info(f"✅ Audio loaded successfully!")
+            
+            return (sr, wav), (sr, wav.copy()), gr.update(value=(sr, wav), autoplay=True)
+            # except TimeoutError as e:
+            #     log.error(f"Audio download timeout for {filename_to_load}: {e}")
+            #     sentry_sdk.capture_exception(e)
+            #     raise
+            # except ConnectionError as e:
+            #     log.error(f"Audio download connection error for {filename_to_load}: {e}")
+            #     sentry_sdk.capture_exception(e)
+            #     gr.Error(f"🌐 Connection error loading audio: {filename_to_load}. Please check your internet connection.")
+            #     return None, None, gr.update(value=None, autoplay=False)
+            # except FileNotFoundError as e:
+            #     log.error(f"Audio file not found for {filename_to_load}: {e}")
+            #     sentry_sdk.capture_exception(e)
+            #     gr.Error(f"📁 Audio file not found: {filename_to_load}")
+            #     return None, None, gr.update(value=None, autoplay=False)
+            # except Exception as e:
+            #     log.error(f"Audio download failed for {filename_to_load}: {e}")
+            #     sentry_sdk.capture_exception(e)
+            #     gr.Error(f"❌ Failed to load audio: {filename_to_load}. Error: {e}")
+            #     return None, None, gr.update(value=None, autoplay=False)
 
         def load_review_items_fn(session):
             user_id = session.get("user_id")

utils/auth.py

@@ -1,11 +1,11 @@
 import gradio as gr
+import time
 from utils.logger import Logger
 from utils.database import get_db
 from data.repository.annotator_repo import AnnotatorRepo
 from data.repository.annotator_workload_repo import AnnotatorWorkloadRepo
 from utils.security import verify_password
 from config import conf
-import time # Add this import
 
 log = Logger()
 

utils/database.py

@@ -51,7 +51,8 @@ def get_db():
     # except Exception as e:
     #     db.rollback()
     #     log.error(f"Database error: {e}")
-    #     raise
+    #     sentry_sdk.capture_exception(e)  # Add Sentry logging
+    #     raise  # Re-raise for debugging
     # finally:
     db.close()
 
@@ -65,3 +66,5 @@ def initialize_database():
     log.info("Tables created successfully")
     # except Exception as e:
     #     log.error(f"Table creation failed: {e}")
+    #     sentry_sdk.capture_exception(e)
+    #     raise