Update annotation_tool , Add description Tool and replace viewer.py

Author: Jintao Ma

annotation_tool/controllers/description/.DS_Store

@@ -0,0 +1,152 @@
+import copy
+from PyQt6.QtCore import QModelIndex
+from PyQt6.QtWidgets import QMessageBox
+from models.project_tree import ProjectTreeModel
+
+class DescAnnotationManager:
+    """
+    Manages data loading and saving for Description Mode (Right Panel).
+    Handles the formatting of Q&A from JSON and flattening it upon save.
+    """
+    def __init__(self, main_window):
+        self.main = main_window
+        self.model = main_window.model
+        self.ui = main_window.ui.description_ui.right_panel
+        self.current_action_path = None
+
+    def setup_connections(self):
+        """Connect UI signals to controller methods."""
+        # Listen to Tree Selection from the Description Panel
+        tree = self.main.ui.description_ui.left_panel.tree
+        tree.selectionModel().currentChanged.connect(self.on_item_selected)
+        
+        # Connect Editor Buttons
+        self.ui.confirm_clicked.connect(self.save_current_annotation)
+        self.ui.clear_clicked.connect(self.clear_current_text)
+
+    def on_item_selected(self, current: QModelIndex, previous: QModelIndex):
+        """
+        Triggered when a tree item is selected. 
+        Loads the corresponding data into the text editor.
+        """
+        if not current.isValid():
+            self.ui.caption_edit.clear()
+            self.current_action_path = None
+            self.ui.caption_edit.setEnabled(False)
+            return
+
+        # 1. Identify the Action Path
+        path = current.data(ProjectTreeModel.FilePathRole)
+        model = self.main.tree_model
+        
+        # If user clicked a child (video), find the parent (action) to show shared annotations
+        if not model.hasChildren(current) and current.parent().isValid():
+            parent_idx = current.parent()
+            path = parent_idx.data(ProjectTreeModel.FilePathRole)
+        
+        self.current_action_path = path
+        self.ui.caption_edit.setEnabled(True)
+        
+        # 2. Find Data Object in Model
+        # 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)
+
+        if not action_data:
+            self.ui.caption_edit.setPlaceholderText("No metadata found for this item.")
+            return
+
+        # 3. Format and Display Text
+        self._load_and_format_text(action_data)
+
+    def _load_and_format_text(self, data):
+        """
+        Formats the display text. 
+        - If 'captions' contains 'question' fields, formats as Q&A blocks.
+        - If 'captions' is plain text (already saved), displays it directly.
+        """
+        captions = data.get("captions", [])
+        formatted_blocks = []
+
+        if captions:
+            # Iterate through existing captions (which might be raw Q&A or edited text)
+            for cap in captions:
+                text = cap.get("text", "")
+                question = cap.get("question", "") # Check for the 'question' key
+                
+                if question:
+                    # Format as Q & A if the question key exists
+                    formatted_blocks.append(f'Q: "{question}"\nA: "{text}"')
+                else:
+                    # Otherwise, just append the text (e.g. for already edited/flattened descriptions)
+                    formatted_blocks.append(text)
+            
+            full_text = "\n\n".join(formatted_blocks)
+        
+        else:
+            # Fallback: If no captions exist yet, try to generate template from metadata questions
+            metadata = data.get("metadata", {})
+            questions = metadata.get("questions", [])
+            for i, q in enumerate(questions):
+                formatted_blocks.append(f'Q: "{q}"\nA: ""')
+            
+            full_text = "\n\n".join(formatted_blocks)
+
+        self.ui.caption_edit.setPlainText(full_text)
+
+    def save_current_annotation(self):
+        """
+        Saves the current text content back to the JSON model.
+        Flattens the structure: removes 'question' keys and saves everything as one text block.
+        """
+        if not self.current_action_path:
+            return
+
+        text_content = self.ui.caption_edit.toPlainText()
+        
+        # Find the target data item in the model
+        target_item = None
+        for item in self.model.action_item_data:
+            if item.get("metadata", {}).get("path") == self.current_action_path:
+                target_item = item
+                break
+        
+        if target_item:
+            # [CRITICAL UPDATE]
+            # Replace the entire 'captions' list with a single entry containing the full text.
+            # This effectively removes the old 'question' fields from the JSON structure
+            # and stores the user's edited content purely as 'text'.
+            target_item["captions"] = [
+                {
+                    "lang": "en", 
+                    "text": text_content
+                }
+            ]
+            
+            # Mark state as dirty so Save button becomes active
+            self.model.is_data_dirty = True
+            self.main.update_save_export_button_state()
+            
+            # Update Tree Icon (Done/Empty)
+            is_done = bool(text_content.strip())
+            self._update_tree_icon(self.current_action_path, is_done)
+            
+            self.main.show_temp_msg("Saved", "Description updated.")
+            
+            # Auto-advance to next item
+            self._auto_advance()
+
+    def clear_current_text(self):
+        """Clears the editor text."""
+        self.ui.caption_edit.clear()
+
+    def _update_tree_icon(self, path, is_done):
+        """Updates the checkmark icon in the tree view."""
+        item = self.model.action_item_map.get(path)
+        if item:
+            item.setIcon(self.main.done_icon if is_done else self.main.empty_icon)
+
+    def _auto_advance(self):
+        """Moves selection to the next Action in the tree automatically."""
+        self.main.desc_nav_manager.nav_next_action()

annotation_tool/controllers/description/__init__.py

@@ -0,0 +1,149 @@
+import json
+import os
+from PyQt6.QtWidgets import QFileDialog, QMessageBox
+
+class DescFileManager:
+    """
+    Handles JSON I/O for the Description / Video Captioning mode.
+    Responsible for populating the ProjectTreeModel and saving data back to disk.
+    """
+    def __init__(self, main_window):
+        self.main = main_window
+        self.model = main_window.model  # AppStateModel
+
+    def create_new_project(self):
+        """
+        Initializes a fresh Description project state.
+        """
+        # 1. Reset Global State
+        self._clear_workspace(full_reset=True)
+        
+        # 2. Set Task Metadata
+        self.model.current_task_name = "video_captioning"
+        self.model.json_loaded = True
+        self.model.is_data_dirty = True
+        self.model.current_working_directory = None
+        self.model.current_json_path = None
+        
+        # 3. Setup UI for blank state
+        self.main.prepare_new_description_ui()
+        self.main.ui.show_description_view()
+        self.main.update_save_export_button_state()
+        
+        self.main.show_temp_msg("New Project", "Description project created. Use 'Add Data' to start.")
+
+    def load_project(self, data: dict, file_path: str):
+        """
+        Loads the JSON data into the Model and populates the Tree View.
+        """
+        self._clear_workspace(full_reset=False)
+        self.model.current_json_path = file_path
+        self.model.current_working_directory = os.path.dirname(file_path)
+        
+        # 1. Store Raw Data
+        self.model.action_item_data = data.get("data", [])
+        self.model.current_task_name = data.get("task", "video_captioning")
+        
+        # 2. Populate the Tree
+        self._populate_tree()
+        
+        # 3. Finalize UI
+        self.model.json_loaded = True
+        self.model.is_data_dirty = False
+        self.main.setWindowTitle(f"SoccerNet Pro - {os.path.basename(file_path)}")
+        self.main.update_save_export_button_state()
+        
+        self.main.show_temp_msg("Loaded", f"Loaded {len(self.model.action_item_data)} actions.")
+
+    def save_json(self) -> bool:
+        """Saves the current state back to JSON."""
+        if not self.model.current_json_path:
+            return self.save_as_json()
+
+        # Construct data dictionary
+        output_data = {
+            "version": "1.0",
+            "task": self.model.current_task_name,
+            "data": self.model.action_item_data
+        }
+        # Preserve metadata if available in model (optional expansion)
+
+        try:
+            with open(self.model.current_json_path, 'w', encoding='utf-8') as f:
+                json.dump(output_data, f, indent=2, ensure_ascii=False)
+            
+            self.model.is_data_dirty = False
+            self.main.update_save_export_button_state()
+            self.main.show_temp_msg("Saved", "Project saved successfully.")
+            return True
+        except Exception as e:
+            QMessageBox.critical(self.main, "Save Error", f"Failed to save JSON:\n{e}")
+            return False
+
+    def save_as_json(self) -> bool:
+        path, _ = QFileDialog.getSaveFileName(
+            self.main, "Save Project As", "", "JSON Files (*.json)"
+        )
+        if not path:
+            return False
+            
+        self.model.current_json_path = path
+        return self.save_json()
+
+    def export_json(self):
+        """Export logic (currently same as save as)."""
+        self.save_as_json()
+
+    def _populate_tree(self):
+        """
+        Converts JSON structure into the QStandardItemModel.
+        """
+        tree_model = self.main.tree_model
+        tree_model.clear()
+        self.model.action_item_map.clear()
+
+        # Iterate through the JSON 'data' list
+        for item in self.model.action_item_data:
+            # A. Get Display Name (Action ID)
+            action_id = item.get("id", "Unknown ID")
+            
+            # B. Get Metadata Path
+            action_path = item.get("metadata", {}).get("path", action_id)
+            
+            # C. Extract Video Paths from 'inputs' list
+            input_paths = []
+            inputs = item.get("inputs", [])
+            for inp in inputs:
+                if isinstance(inp, dict) and "path" in inp:
+                    input_paths.append(inp["path"])
+            
+            # D. Add to Tree Model
+            tree_item = tree_model.add_entry(
+                name=action_id,
+                path=action_path,
+                source_files=input_paths
+            )
+            
+            # Store mapping
+            self.model.action_item_map[action_path] = tree_item
+            
+            # E. Check Status
+            captions = item.get("captions", [])
+            has_content = len(captions) > 0 and bool(captions[0].get("text", "").strip())
+            
+            if has_content:
+                tree_item.setIcon(self.main.done_icon)
+            else:
+                tree_item.setIcon(self.main.empty_icon)
+
+    def _clear_workspace(self, full_reset=True):
+        """Clears the tree and model state."""
+        self.main.tree_model.clear()
+        self.model.action_item_map.clear()
+        if full_reset:
+            self.model.json_loaded = False
+            self.model.current_json_path = None
+            self.model.action_item_data = []
+            self.model.is_data_dirty = False
+            self.main.ui.description_ui.right_panel.caption_edit.clear()
+            self.main.ui.description_ui.right_panel.caption_edit.setEnabled(False)