Merge branch 'main' of hf.co:spaces/navidved/tts_labeling

components/dashboard_page.py

@@ -188,7 +188,7 @@ class DashboardPage:
                     log.error(f"Error fetching progress for user {user_id}: {e}") 
                     return "Annotation Progress: Error" # Added label
 
-        def download_voice_fn(folder_link, filename_to_load, autoplay_on_load=False): # Autoplay here is for the btn_load_voice click
+        def download_voice_fn(folder_link, 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:
@@ -324,22 +324,14 @@ class DashboardPage:
 
             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.")
-                # Prepare default/empty values for all outputs of show_current_item_fn
-                # (tts_id, filename, sentence, ann_text, audio_placeholder, 
-                #  trim_start_sec_ui, trim_end_sec_ui, 
-                #  applied_trims_list_state_val, trims_display_val, audio_update_obj)
                 empty_item_display_tuple = ("", "", "", "", None, None, None, [], self._convert_trims_to_df_data([]), gr.update(value=None, autoplay=False))
-                
-                # load_all_items_fn returns: [items_to_load, initial_idx] + list(initial_ui_values_tuple) + [progress_str]
-                # Total 13 values.
-                return [[], 0] + list(empty_item_display_tuple) + ["Progress: Waiting for login..."]
+                return [[], 0] + list(empty_item_display_tuple) + ["Progress: loading data..."]
 
             if user_id:
                 with get_db() as db:
                     try:
                         repo = AnnotatorWorkloadRepo(db)
-                        # Get all assigned items
-                        raw_items = repo.get_tts_data_with_annotations_for_user_id(user_id) 
+                        raw_items = repo.get_tts_data_with_annotations_for_user_id(user_id, annotator_name_for_log=user_name) 
                         
                         items_to_load = [
                             {
@@ -353,24 +345,25 @@ class DashboardPage:
                         log.info(f"Loaded {len(items_to_load)} items for user {user_name} (ID: {user_id})")
 
                         # --- Resume Logic: Find first unannotated or last item ---
-                        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']})")
-                        elif items_to_load: # All annotated, start at the last one or first if only one
-                            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']})")
+                        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.")
+                            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}") # Removed exc_info=True
+                        log.error(f"Failed to load items or determine resume index for user {user_name}: {e}")
                         gr.Error(f"Could not load your assigned data: {e}")
             
             initial_ui_values_tuple = show_current_item_fn(items_to_load, initial_idx, sess)
@@ -664,65 +657,67 @@ class DashboardPage:
     def _apply_multiple_trims_fn(self, original_audio_data, trims_list_sec):
         if not original_audio_data:
             log.warning("apply_multiple_trims_fn: No original audio data.")
-            return None, gr.update(value=None, autoplay=False)
+            return None, gr.update(value=None, autoplay=False) # Keep False if no audio
         
         sr, wav_orig = original_audio_data
+        current_wav = wav_orig.copy() # Start with a copy of the original waveform
         
         if not trims_list_sec: # No trims to apply
-            log.info("apply_multiple_trims_fn: No trims in list, returning original audio.")
-            return (sr, wav_orig.copy()), gr.update(value=(sr, wav_orig.copy()), autoplay=False)
+            log.info("apply_multiple_trims_fn: No trims in list, returning original audio with autoplay.")
+            # Autoplay is True here as this function is called after audio load
+            return (sr, current_wav), gr.update(value=(sr, current_wav), autoplay=True)
+
+        log.info(f"Applying {len(trims_list_sec)} trims sequentially. Initial shape: {current_wav.shape}, Initial duration: {len(current_wav)/sr:.3f}s")
 
-        delete_intervals_samples = []
-        for trim_info in trims_list_sec:
+        for i, trim_info in enumerate(trims_list_sec):
             start_s = trim_info.get('start_sec')
             end_s = trim_info.get('end_sec')
-            if start_s is not None and end_s is not None and end_s > start_s and start_s >= 0:
-                start_sample = int(sr * start_s)
-                end_sample = int(sr * end_s)
-                start_sample = max(0, min(start_sample, len(wav_orig)))
-                end_sample = max(start_sample, min(end_sample, len(wav_orig)))
-                if start_sample < end_sample:
-                     delete_intervals_samples.append((start_sample, end_sample))
-            else:
-                log.warning(f"apply_multiple_trims_fn: Invalid trim skipped: {trim_info}")
 
-        if not delete_intervals_samples:
-            log.info("apply_multiple_trims_fn: No valid trims to apply, returning original audio.")
-            return (sr, wav_orig.copy()), gr.update(value=(sr, wav_orig.copy()), autoplay=False)
+            # Validate trim times for the current audio segment
+            if not (start_s is not None and end_s is not None and end_s > start_s and start_s >= 0):
+                log.warning(f"Trim {i+1}/{len(trims_list_sec)}: Invalid trim definition skipped: {trim_info}")
+                continue
 
-        delete_intervals_samples.sort(key=lambda x: x[0])
+            if len(current_wav) == 0:
+                log.warning(f"Trim {i+1}/{len(trims_list_sec)}: Audio is already empty, skipping remaining trims.")
+                break # No more audio to trim
 
-        merged_delete_intervals = []
-        if delete_intervals_samples:
-            current_start, current_end = delete_intervals_samples[0]
-            for next_start, next_end in delete_intervals_samples[1:]:
-                if next_start < current_end:
-                    current_end = max(current_end, next_end)
-                else:
-                    merged_delete_intervals.append((current_start, current_end))
-                    current_start, current_end = next_start, next_end
-            merged_delete_intervals.append((current_start, current_end))
-        
-        log.info(f"apply_multiple_trims_fn: Original wav shape: {wav_orig.shape}, Merged delete intervals (samples): {merged_delete_intervals}")
-
-        kept_parts_wav = []
-        current_pos_samples = 0
-        for del_start, del_end in merged_delete_intervals:
-            if del_start > current_pos_samples:
-                kept_parts_wav.append(wav_orig[current_pos_samples:del_start])
-            current_pos_samples = del_end
-        
-        if current_pos_samples < len(wav_orig):
-            kept_parts_wav.append(wav_orig[current_pos_samples:])
-
-        if not kept_parts_wav:
-            final_wav = np.array([], dtype=wav_orig.dtype)
-            log.info("apply_multiple_trims_fn: All audio trimmed, resulting in empty audio.")
-        else:
-            final_wav = np.concatenate(kept_parts_wav)
-            log.info(f"apply_multiple_trims_fn: Final wav shape after trimming: {final_wav.shape}")
+            current_duration_s = len(current_wav) / sr
+            log.info(f"Trim {i+1}: Processing trim {trim_info} on audio of current duration {current_duration_s:.3f}s.")
+
+            # Convert seconds to sample indices for the current waveform
+            start_sample = int(sr * start_s)
+            end_sample = int(sr * end_s)
             
-        return (sr, final_wav), gr.update(value=(sr, final_wav), autoplay=False)
+            current_len_samples = len(current_wav)
+            
+            # Clamp sample indices to the bounds of the current waveform
+            # Ensure start_sample is not past the end of the current audio
+            start_sample = max(0, min(start_sample, current_len_samples))
+            # Ensure end_sample is not past the end, and not before start_sample
+            end_sample = max(start_sample, min(end_sample, current_len_samples))
+
+            if start_sample < end_sample: # If there's a segment to remove
+                log.info(f"Trim {i+1}: Applying samples {start_sample}-{end_sample} to current audio (length {current_len_samples} samples). Shape before: {current_wav.shape}")
+                
+                part1 = current_wav[:start_sample]
+                part2 = current_wav[end_sample:]
+                
+                if len(part1) == 0 and len(part2) == 0: # The entire current audio segment was trimmed
+                    current_wav = np.array([], dtype=wav_orig.dtype)
+                elif len(part1) == 0: # Trimmed from the beginning of the current segment
+                    current_wav = part2
+                elif len(part2) == 0: # Trimmed to the end of the current segment
+                    current_wav = part1
+                else: # Trimmed from the middle of the current segment
+                    current_wav = np.concatenate((part1, part2))
+                log.info(f"Trim {i+1}: Shape after: {current_wav.shape}, New duration: {len(current_wav)/sr:.3f}s")
+            else:
+                log.info(f"Trim {i+1}: No effective change for trim {trim_info} on current audio (start_sample >= end_sample after clamping or trim times out of bounds for current audio).")
+
+        log.info(f"Finished sequential trimming. Final shape: {current_wav.shape}, Final duration: {len(current_wav)/sr:.3f}s")
+        # Autoplay is True here as this function is called after audio load and processing
+        return (sr, current_wav), gr.update(value=(sr, current_wav), autoplay=True)
 
     def _convert_trims_to_df_data(self, trims_list_sec):
         if not trims_list_sec:

scripts/import_annotations_from_json.py

@@ -35,7 +35,7 @@ def import_annotations(db: SQLAlchemySession, data: dict): # Changed SessionLoca
     tts_data_cache = {}
     annotator_cache = {}
     
-    annotation_ids_for_trim_deletion_in_batch = [] # For batch deletion of trims
+    # annotation_ids_for_trim_deletion_in_batch = [] # Removed
 
     # Create a mapping from JSON ID to sample data for efficient lookup
     samples_by_id = {s.get("id"): s for s in samples if s.get("id") is not None}
@@ -200,6 +200,11 @@ def import_annotations(db: SQLAlchemySession, data: dict): # Changed SessionLoca
             ).first()
 
             if annotation_obj:
+                # If annotation exists, delete its old trims first
+                if annotation_obj.id:
+                    # log.debug(f"Deleting existing trims for Annotation ID {annotation_obj.id} before updating.")
+                    db.query(AudioTrim).filter(AudioTrim.annotation_id == annotation_obj.id).delete(synchronize_session=False)
+                
                 annotation_obj.annotated_sentence = final_annotated_sentence
                 annotation_obj.annotated_at = final_annotated_at
                 updated_count +=1
@@ -221,8 +226,8 @@ def import_annotations(db: SQLAlchemySession, data: dict): # Changed SessionLoca
                     continue 
             
             if annotation_obj.id: 
-                if annotation_obj.id not in annotation_ids_for_trim_deletion_in_batch:
-                    annotation_ids_for_trim_deletion_in_batch.append(annotation_obj.id)
+                # Removed: if annotation_obj.id not in annotation_ids_for_trim_deletion_in_batch:
+                # Removed:     annotation_ids_for_trim_deletion_in_batch.append(annotation_obj.id)
                 
                 json_audio_trims = json_ann.get("audio_trims", [])
                 if json_audio_trims:
@@ -260,10 +265,11 @@ def import_annotations(db: SQLAlchemySession, data: dict): # Changed SessionLoca
         samples_processed_in_batch += 1
 
         if samples_processed_in_batch >= BATCH_SIZE or (sample_idx == len(samples) - 1):
-            if annotation_ids_for_trim_deletion_in_batch:
-                log.info(f"Batch deleting trims for {len(annotation_ids_for_trim_deletion_in_batch)} annotations in current batch.")
-                db.query(AudioTrim).filter(AudioTrim.annotation_id.in_(annotation_ids_for_trim_deletion_in_batch)).delete(synchronize_session=False)
-                annotation_ids_for_trim_deletion_in_batch.clear()
+            # Removed the block for batch deleting trims that used annotation_ids_for_trim_deletion_in_batch
+            # if annotation_ids_for_trim_deletion_in_batch:
+            #     log.info(f"Batch deleting trims for {len(annotation_ids_for_trim_deletion_in_batch)} annotations in current batch.")
+            #     db.query(AudioTrim).filter(AudioTrim.annotation_id.in_(annotation_ids_for_trim_deletion_in_batch)).delete(synchronize_session=False)
+            #     annotation_ids_for_trim_deletion_in_batch.clear()
             
             try:
                 db.commit()
@@ -271,7 +277,6 @@ def import_annotations(db: SQLAlchemySession, data: dict): # Changed SessionLoca
             except Exception as e_commit:
                 db.rollback()
                 log.error(f"Failed to commit batch after sample index {sample_idx} (TTSData JSON ID {current_sample_json_id}): {e_commit}. Rolling back this batch.")
-                annotation_ids_for_trim_deletion_in_batch.clear() 
             finally:
                  samples_processed_in_batch = 0 # Reset for next batch or end