implemented strict cross-modal JSON validation in Description and Dense-Description with detailed error reporting, preserved global and item-level metadata during I/O, and resolved UI synchronization issues regarding hierarchical clip structures and annotation status indicators.

Author: Jintao Ma

annotation_tool/controllers/classification/class_file_manager.py

@@ -11,13 +11,40 @@ def __init__(self, main_window):
         self.ui = main_window.ui
 
     def load_project(self, data, file_path):
-        """Load Classification Project"""
+        """
+        Load Classification Project.
+        Returns:
+            bool: True if loaded successfully, False if validation failed or cancelled.
+        """
+        
+        # 1. Strict Validation
         valid, err, warn = self.model.validate_gac_json(data)
+        
         if not valid:
-            QMessageBox.critical(self.main, "JSON Error", err); return
+             # Truncate extremely long error messages for display
+            if len(err) > 1000:
+                err = err[:1000] + "\n... (truncated)"
+            
+            QMessageBox.critical(
+                self.main, 
+                "Validation Error (Classification)", 
+                "The imported JSON contains critical errors and cannot be loaded.\n\n" + err
+            )
+            return False # [FIX] Return False to signal failure
+            
         if warn:
-            QMessageBox.warning(self.main, "Warnings", warn)
+            if len(warn) > 1000:
+                warn = warn[:1000] + "\n... (truncated)"
 
+            res = QMessageBox.warning(
+                self.main, "Validation Warnings", 
+                "The file contains warnings:\n\n" + warn + "\n\nContinue loading?",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            )
+            if res != QMessageBox.StandardButton.Yes:
+                return False # [FIX] Return False on user cancel
+            
+        # 2. Clear Workspace (Only if validation passed)
         self._clear_workspace(full_reset=True)
 
         self.model.current_working_directory = os.path.dirname(file_path)
@@ -80,13 +107,14 @@ def load_project(self, data, file_path):
         self.main.populate_action_tree()
         self.main.update_save_export_button_state()
 
-        # 2s block
         self.main.show_temp_msg(
             "Mode Switched", 
             f"Project loaded with {len(self.model.action_item_data)} items.\n\nCurrent Mode: CLASSIFICATION",
             duration=1500,
             icon=QMessageBox.Icon.Information
         )
+        
+        return True # [FIX] Explicitly return True on success
 
     def save_json(self):
         if self.model.current_json_path: 

annotation_tool/controllers/dense_description/dense_file_manager.py

@@ -1,23 +1,25 @@
 import os
 import json
+import datetime
 from PyQt6.QtWidgets import QFileDialog, QMessageBox
 from PyQt6.QtCore import QUrl
 from utils import natural_sort_key
 
 class DenseFileManager:
     """
     Handles JSON I/O for Dense Video Captioning projects.
+    Includes validation and metadata preservation.
     """
     def __init__(self, main_window):
         self.main = main_window
         self.model = main_window.model
 
     def create_new_project(self):
         """
-        [NEW] Create a new Dense Description project (Blank).
-        This method initializes the workspace for a fresh project.
+        Create a new Dense Description project (Blank).
+        Initializes default metadata and workspace.
         """
-        # 1. Safety Check: Ensure current project is closed/saved first
+        # 1. Safety Check
         if not self.main.check_and_close_current_project():
             return
 
@@ -30,61 +32,113 @@ def create_new_project(self):
         self.model.modalities = ["video"]
         self.model.dense_description_events = {}
 
+        # [NEW] Initialize default Global Metadata for new projects
+        self.model.dense_global_metadata = {
+            "version": "1.0",
+            "date": datetime.date.today().isoformat(),
+            "metadata": {
+                "source": "SoccerNet Annotation Tool",
+                "created_by": "User",
+                "license": "CC-BY-NC 4.0"
+            }
+        }
+        
         # Reset paths
         self.model.current_working_directory = None
         self.model.current_json_path = None
 
-        # [CRITICAL] Mark as loaded to enable UI interactions (Add Video, Save, etc.)
+        # Mark as loaded
         self.model.json_loaded = True
         self.model.is_data_dirty = True
 
         # 4. Refresh UI
-        # Clear tree (it's a new project, so it starts empty)
         self.main.dense_manager.populate_tree()
-        
-        # Switch View to Index 4 (Dense Description)
         self.main.ui.show_dense_description_view()
         self.main.update_save_export_button_state()
 
-        # Unlock the specific Dense UI panels (Right panel, etc.)
         if hasattr(self.main, "prepare_new_dense_ui"):
             self.main.prepare_new_dense_ui()
 
         self.main.statusBar().showMessage("Project Created — Dense Description Workspace Ready", 5000)
 
     def load_project(self, data, file_path):
-        """Loads dense description project from JSON data."""
-        # 1. Clear workspace
+        """
+        Loads dense description project from JSON data.
+        Performs strict validation and preserves metadata.
+        """
+        # --- [STEP 1] VALIDATION ---
+        # Call the strict validator defined in AppStateModel
+        if hasattr(self.model, "validate_dense_json"):
+            is_valid, error_msg, warning_msg = self.model.validate_dense_json(data)
+
+            if not is_valid:
+                # Truncate extremely long error messages for display
+                if len(error_msg) > 1000:
+                    error_msg = error_msg[:1000] + "\n... (truncated)"
+                
+                QMessageBox.critical(
+                    self.main,
+                    "Validation Error (Dense Description)",
+                    "The imported JSON contains critical errors and cannot be loaded.\n\n" + error_msg,
+                )
+                return False
+
+            if warning_msg:
+                # Show warnings but allow loading to proceed
+                if len(warning_msg) > 1000:
+                    warning_msg = warning_msg[:1000] + "\n... (truncated)"
+                res = QMessageBox.warning(
+                    self.main,
+                    "Validation Warnings",
+                    "The file contains warnings:\n\n"
+                    + warning_msg
+                    + "\n\nDo you want to continue loading?",
+                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                )
+                if res != QMessageBox.StandardButton.Yes:
+                    return False
+
+        # --- [STEP 2] CLEAR & SETUP ---
         self._clear_workspace(full_reset=True)
 
         project_root = os.path.dirname(os.path.abspath(file_path))
         self.model.current_working_directory = project_root
-        self.model.current_task_name = data.get("task", "Dense Captioning")
+        self.model.current_task_name = data.get("dataset_name", data.get("task", "Dense Captioning"))
+
+        # [NEW] Preserve Global Metadata
+        self.model.dense_global_metadata = {
+            "version": data.get("version", "1.0"),
+            "date": data.get("date", datetime.date.today().isoformat()),
+            "metadata": data.get("metadata", {})
+        }
 
         missing_files = []
         loaded_count = 0
 
-        # 2. Iterate through items
+        # --- [STEP 3] LOAD ITEMS ---
         for item in data.get("data", []):
             inputs = item.get("inputs", [])
             if not inputs: continue
 
             raw_path = inputs[0].get("path", "")
+            # ID Priority: explicit 'id' -> filename without extension
             aid = item.get("id") or os.path.splitext(os.path.basename(raw_path))[0]
 
-            # Resolve relative/absolute path
+            # Resolve Path
             final_path = os.path.normpath(os.path.join(project_root, raw_path))
             if not os.path.exists(final_path):
                 missing_files.append(aid)
 
-            # Register in Model
+            # [NEW] Preserve Item-level Metadata (using AppState's imported_action_metadata)
+            if "metadata" in item:
+                self.model.imported_action_metadata[aid] = item["metadata"]
+
+            # Register Clip
             self.model.action_item_data.append({"name": aid, "path": final_path, "source_files": [final_path]})
             self.model.action_path_to_name[final_path] = aid
 
-            # [FIXED] Process Dense Events using the correct key 'dense_captions'
-            # Looking for 'dense_captions' first, fallback to 'events'
+            # Load Events (dense_captions)
             events = item.get("dense_captions", item.get("events", []))
-            
             if events:
                 self.model.dense_description_events[final_path] = []
                 for e in events:
@@ -98,9 +152,14 @@ def load_project(self, data, file_path):
         self.model.current_json_path = file_path
         self.model.json_loaded = True
 
-        # 3. Refresh UI
+        # --- [STEP 4] FINALIZE ---
         self.main.dense_manager.populate_tree()
-        self.main.statusBar().showMessage(f"Dense Mode: Loaded {loaded_count} clips.", 2000)
+        
+        if missing_files:
+            QMessageBox.warning(self.main, "Load Warning", f"Could not find {len(missing_files)} video files locally.")
+        else:
+            self.main.statusBar().showMessage(f"Dense Mode: Loaded {loaded_count} clips.", 2000)
+            
         return True
 
     def overwrite_json(self):
@@ -114,33 +173,41 @@ def export_json(self):
         return False
 
     def _write_json(self, path):
-        """Serializes current dense description state to JSON."""
+        """Serializes current dense description state to JSON, preserving all metadata."""
+        
+        # [NEW] Retrieve Global Metadata from Model (or defaults)
+        global_meta = getattr(self.model, "dense_global_metadata", {})
+        
         output = {
-            "version": "1.0",
+            "version": global_meta.get("version", "1.0"),
+            "date": global_meta.get("date", datetime.date.today().isoformat()),
             "task": "dense_video_captioning",
             "dataset_name": self.model.current_task_name,
+            "metadata": global_meta.get("metadata", {
+                "source": "SoccerNet Annotation Tool",
+                "created_by": "User"
+            }),
             "data": []
         }
 
         base_dir = os.path.dirname(path)
 
-        # Sort items naturally so the output JSON is ordered
         sorted_items = sorted(
             self.model.action_item_data, key=lambda d: natural_sort_key(d.get("name", ""))
         )
 
         for data in sorted_items:
             abs_path = data["path"]
+            aid = data["name"]
             events = self.model.dense_description_events.get(abs_path, [])
 
             try:
                 rel_path = os.path.relpath(abs_path, base_dir).replace(os.sep, "/")
             except:
                 rel_path = abs_path
 
-            # Export events with 'text' field
+            # Format Events
             export_events = []
-            # Sort events by time before export
             sorted_events = sorted(events, key=lambda x: x.get("position_ms", 0))
 
             for e in sorted_events:
@@ -150,12 +217,19 @@ def _write_json(self, path):
                     "text": e["text"]
                 })
 
-            output["data"].append({
-                "id": data["name"],
-                "inputs": [{"type": "video", "path": rel_path}],
-                # [FIXED] Use 'dense_captions' to maintain consistency with input format
+            # Build Item Entry
+            entry = {
+                "id": aid,
+                "inputs": [{"type": "video", "path": rel_path, "fps": 25}], # FPS is hardcoded or needs retrieval
                 "dense_captions": export_events
-            })
+            }
+            
+            # [NEW] Inject Item-level Metadata if available
+            item_meta = self.model.imported_action_metadata.get(aid)
+            if item_meta:
+                entry["metadata"] = item_meta
+                
+            output["data"].append(entry)
 
         try:
             with open(path, "w", encoding="utf-8") as f:
@@ -172,10 +246,12 @@ def _write_json(self, path):
     def _clear_workspace(self, full_reset=False):
         """Resets the workspace for Dense Description mode."""
         self.model.reset(full_reset)
+        
+        # [NEW] Clear global metadata explicitly if full reset
+        if full_reset:
+             self.model.dense_global_metadata = {}
+
         if hasattr(self.main, "dense_manager"):
-            # Stop playback
             self.main.dense_manager.media_controller.stop()
-            # Clear table
             self.main.dense_manager.right_panel.table.set_data([])
-            # Clear text input
-            self.main.dense_manager.right_panel.input_widget.set_text("")
+            self.main.dense_manager.right_panel.input_widget.set_text("")

annotation_tool/controllers/description/desc_annotation_manager.py

@@ -54,7 +54,8 @@ def on_item_selected(self, current: QModelIndex, previous: QModelIndex):
         # We search by path first, fallback to ID if needed
         action_data = next((item for item in self.model.action_item_data if item.get("metadata", {}).get("path") == path), None)
         if not action_data:
-             action_data = next((item for item in self.model.action_item_data if item.get("id") == current.text()), None)
+             #action_data = next((item for item in self.model.action_item_data if item.get("id") == current.text()), None)
+             action_data = next((item for item in self.model.action_item_data if item.get("id") == current.data()), None)
 
         if not action_data:
             self.ui.caption_edit.setPlaceholderText("No metadata found for this item.")