synapse-sdk 1.0.0b5__py3-none-any.whl → 2025.12.3__py3-none-any.whl

synapse_sdk/utils/converters/dm/from_v1.py

@@ -1,627 +1,273 @@
-from . import BaseDMConverter
+"""
+DM Schema V1 → V2 Converter
+
+Created: 2025-12-11
+
+V1→V2 conversion separates the result into annotation_data and annotation_meta.
+"""
+
+from typing import Any
+
+from .base import BaseDMConverter
+from .types import (
+    AnnotationMeta,
+    V2AnnotationData,
+    V2ConversionResult,
+)
 
 
 class DMV1ToV2Converter(BaseDMConverter):
-    """DM v1 to v2 format converter class."""
+    """Converter from DM Schema V1 to V2
 
-    def __init__(self, old_dm_data={}, file_type=None):
-        """Initialize the converter.
+    V1→V2 conversion separates the result into annotation_data and annotation_meta.
 
-        Args:
-            old_dm_data (dict): DM v1 format data to be converted
-            file_type (str, optional): Type of file being converted
-        """
-        super().__init__(file_type)
-        self.old_dm_data = old_dm_data
-        self.classification_info = {}
-        self.media_data = {}
+    Example:
+        >>> converter = DMV1ToV2Converter()
+        >>> result = converter.convert(v1_data)
+        >>> annotation_data = result["annotation_data"]
+        >>> annotation_meta = result["annotation_meta"]
+    """
 
-    def convert(self):
-        """Convert DM v1 data to v2 format.
+    def _setup_tool_processors(self) -> None:
+        """Register tool processors"""
+        from .tools.bounding_box import BoundingBoxProcessor
 
-        Returns:
-            dict: Converted data in DM v2 format
-        """
-        # Reset state
-        old_dm_data = self.old_dm_data
-        self.classification_info = {}
-        self.media_data = {}
+        self.register_processor(BoundingBoxProcessor())
 
-        # Extract media IDs from annotations key
-        media_ids = list(old_dm_data.get('annotations', {}).keys())
+        # polygon to be added later
+        try:
+            from .tools.polygon import PolygonProcessor
 
-        # If file_type is not specified, try to detect from media_ids
-        if not self.file_type and media_ids:
-            detected_file_type = self._detect_file_type(media_ids[0])
-            if detected_file_type:
-                self.file_type = detected_file_type
-                # Re-setup tool processors with detected file_type
-                self.tool_processors = self._setup_tool_processors()
+            self.register_processor(PolygonProcessor())
+        except ImportError:
+            pass
 
-        for media_id in media_ids:
-            self._convert_media_item(old_dm_data, media_id)
+        try:
+            from .tools.polyline import PolylineProcessor
 
-        # Build final result (put classification at the front)
-        result = {'classification': self.classification_info}
-        result.update(self.media_data)
+            self.register_processor(PolylineProcessor())
+        except ImportError:
+            pass
 
-        return result
+        try:
+            from .tools.keypoint import KeypointProcessor
 
-    def _detect_file_type(self, media_id):
-        """Detect file type from media ID."""
-        if '_' in media_id:
-            return media_id.split('_')[0]
-        return media_id
+            self.register_processor(KeypointProcessor())
+        except ImportError:
+            pass
 
-    def _convert_media_item(self, old_dm_data, media_id):
-        """Process a single media item.
+        try:
+            from .tools.bounding_box_3d import BoundingBox3DProcessor
 
-        Args:
-            old_dm_data (dict): Original DM v1 data
-            media_id (str): ID of the media item to process
-        """
-        # Extract media type (e.g., "video_1" -> "videos", "image_2" -> "images")
-        media_type, media_type_plural = self._extract_media_type_info(media_id)
+            self.register_processor(BoundingBox3DProcessor())
+        except ImportError:
+            pass
 
-        # Create list for this media type if it doesn't exist
-        if media_type_plural not in self.media_data:
-            self.media_data[media_type_plural] = []
+        try:
+            from .tools.segmentation import SegmentationProcessor
 
-        # Create id -> class and tool mappings
-        annotations = old_dm_data.get('annotations', {}).get(media_id, [])
+            self.register_processor(SegmentationProcessor())
+        except ImportError:
+            pass
 
-        id_to_class = {}
-        id_to_tool = {}
-        for annotation in annotations:
-            id_to_class[annotation['id']] = annotation['classification']['class']
-            id_to_tool[annotation['id']] = annotation['tool']
+        try:
+            from .tools.named_entity import NamedEntityProcessor
 
-        # Create id -> full classification mapping (including additional attributes)
-        id_to_full_classification = {annotation['id']: annotation['classification'] for annotation in annotations}
+            self.register_processor(NamedEntityProcessor())
+        except ImportError:
+            pass
 
-        # Collect all classifications from annotations (regardless of whether they have data)
-        for annotation in annotations:
-            tool_type = annotation['tool']
-            classification = annotation['classification']['class']
+        try:
+            from .tools.segmentation_3d import Segmentation3DProcessor
 
-            if tool_type not in self.classification_info:
-                self.classification_info[tool_type] = []
+            self.register_processor(Segmentation3DProcessor())
+        except ImportError:
+            pass
 
-            # Add only non-duplicate classifications
-            if classification and classification not in self.classification_info[tool_type]:
-                self.classification_info[tool_type].append(classification)
+        try:
+            from .tools.classification import ClassificationProcessor
 
-        # Initialize current media item
-        media_item = {}
+            self.register_processor(ClassificationProcessor())
+        except ImportError:
+            pass
 
-        # Process data from annotationsData for this media
-        annotations_data = old_dm_data.get('annotationsData', {}).get(media_id, [])
+        try:
+            from .tools.relation import RelationProcessor
 
-        # Group by annotation tool type
-        tools_data = {}
+            self.register_processor(RelationProcessor())
+        except ImportError:
+            pass
 
-        for item in annotations_data:
-            item_id = item.get('id', '')
-            # Get tool and classification info from annotations
-            tool_type = id_to_tool.get(item_id, '')
-            classification = id_to_class.get(item_id, '')
+        try:
+            from .tools.prompt import PromptProcessor
 
-            # Process by each tool type
-            self._convert_annotation_item(
-                item, item_id, tool_type, classification, id_to_full_classification, tools_data, media_type
-            )
+            self.register_processor(PromptProcessor())
+        except ImportError:
+            pass
 
-        # Add processed tool data to media item
-        for tool_type, tool_data in tools_data.items():
-            if tool_data:  # Only add if data exists
-                media_item[tool_type] = tool_data
+        try:
+            from .tools.answer import AnswerProcessor
 
-        # Add media item to result (only if data exists)
-        if media_item:
-            self.media_data[media_type_plural].append(media_item)
+            self.register_processor(AnswerProcessor())
+        except ImportError:
+            pass
 
-    def _convert_annotation_item(
-        self, item, item_id, tool_type, classification, id_to_full_classification, tools_data, media_type
-    ):
-        """Process a single annotation item based on its tool type and media type.
+    def convert(self, v1_data: dict[str, Any]) -> V2ConversionResult:
+        """Convert V1 data to V2 format (separated result)
 
         Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            tool_type (str): Type of annotation tool
-            classification (str): Classification label
-            id_to_full_classification (dict): Mapping of ID to full classification data
-            tools_data (dict): Dictionary to store processed tool data
-            media_type (str): Type of media (image, video, pcd, text)
-        """
-        # Check if tool_processors is available and contains the tool_type
-        if hasattr(self, 'tool_processors') and self.tool_processors:
-            processor = self.tool_processors.get(tool_type)
-            if processor:
-                processor(item, item_id, classification, tools_data, id_to_full_classification)
-            else:
-                self._handle_unknown_tool(tool_type, item_id)
-        else:
-            # Use file_type + tool_type pattern for method names
-            method_name = f'_convert_{media_type}_{tool_type}'
-            if hasattr(self, method_name):
-                method = getattr(self, method_name)
-                method(item, item_id, classification, tools_data, id_to_full_classification)
-            else:
-                self._handle_unknown_tool(tool_type, item_id, media_type)
-
-    def _handle_unknown_tool(self, tool_type, item_id=None, media_type=None):
-        """Handle unknown tool types with consistent warning message."""
-        warning_msg = f"Warning: Unknown tool type '{tool_type}'"
-        if media_type:
-            warning_msg += f' for media type {media_type}'
-        if item_id:
-            warning_msg += f' for item {item_id}'
-        print(warning_msg)
-
-    def _extract_media_type_info(self, media_id):
-        """Extract media type information from media ID."""
-        media_type = media_id.split('_')[0] if '_' in media_id else media_id
-        media_type_plural = media_type + 's' if not media_type.endswith('s') else media_type
-        return media_type, media_type_plural
-
-    def _singularize_media_type(self, media_type_plural):
-        """Convert plural media type to singular."""
-        return media_type_plural.rstrip('s')
-
-    def _process_bounding_box_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process bounding box annotation - common logic.
+            v1_data: DM Schema V1 format data
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
-        """
-        if 'bounding_box' not in tools_data:
-            tools_data['bounding_box'] = []
-
-        # Process coordinate or coordinates
-        coord_data = None
-        if 'coordinate' in item and isinstance(item['coordinate'], dict):
-            # Single coordinate structure (dictionary)
-            coord_data = item['coordinate']
-        elif 'coordinates' in item:
-            # Multiple coordinates structure (video etc.)
-            coords_data = item['coordinates']
-            if coords_data:
-                # Use coordinate data from first key
-                first_key = list(coords_data.keys())[0]
-                coord_data = coords_data[first_key]
-
-        if coord_data and 'width' in coord_data and 'height' in coord_data:
-            data = [
-                coord_data['x'],
-                coord_data['y'],
-                coord_data['width'],
-                coord_data['height'],
-            ]
-
-            tools_data['bounding_box'].append({
-                'id': item_id,
-                'classification': classification,
-                'attrs': [],
-                'data': data,
-            })
-
-    def _convert_bounding_box(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process bounding box annotation."""
-        return self._process_bounding_box_common(item, item_id, classification, tools_data, id_to_full_classification)
-
-    def _convert_named_entity(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process named entity annotation.
+        Returns:
+            V2ConversionResult: Separated conversion result
+                - annotation_data: V2 common annotation structure
+                - annotation_meta: Preserved V1 top-level structure
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
+        Raises:
+            ValueError: Missing required fields or invalid format
         """
-        if 'named_entity' not in tools_data:
-            tools_data['named_entity'] = []
+        # Input validation
+        if 'annotations' not in v1_data:
+            raise ValueError("V1 data requires 'annotations' field")
+        if 'annotationsData' not in v1_data:
+            raise ValueError("V1 data requires 'annotationsData' field")
 
-        # Process named_entity ranges and content
-        entity_data = {}
-        if 'ranges' in item and isinstance(item['ranges'], list):
-            # Store ranges information
-            entity_data['ranges'] = item['ranges']
+        # Create annotation_data
+        annotation_data = self._build_annotation_data(v1_data)
 
-        if 'content' in item:
-            # Store selected text content
-            entity_data['content'] = item['content']
+        # Create annotation_meta (preserve V1 top-level structure)
+        annotation_meta = self._build_annotation_meta(v1_data)
 
-        tools_data['named_entity'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': entity_data,  # Format: {ranges: [...], content: "..."}
-        })
+        return {
+            'annotation_data': annotation_data,
+            'annotation_meta': annotation_meta,
+        }
 
-    def _process_polyline_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process polyline annotation.
+    def _build_annotation_data(self, v1_data: dict[str, Any]) -> V2AnnotationData:
+        """Create annotation_data (V2 common structure) from V1 data
 
         Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
-        """
-        if 'polyline' not in tools_data:
-            tools_data['polyline'] = []
-
-        # Process polyline coordinates
-        polyline_data = []
-        if 'coordinate' in item and isinstance(item['coordinate'], list):
-            # Convert each coordinate point to [x, y] format
-            for point in item['coordinate']:
-                if 'x' in point and 'y' in point:
-                    polyline_data.append([point['x'], point['y']])
-
-        tools_data['polyline'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': polyline_data,  # Format: [[x1, y1], [x2, y2], [x3, y3], ...]
-        })
-
-    def _process_keypoint_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process keypoint annotation.
+            v1_data: V1 data
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
+        Returns:
+            V2 common annotation structure
         """
-        if 'keypoint' not in tools_data:
-            tools_data['keypoint'] = []
-
-        # Process keypoint coordinate (single point)
-        keypoint_data = []
-        if 'coordinate' in item and isinstance(item['coordinate'], dict):
-            coord = item['coordinate']
-            if 'x' in coord and 'y' in coord:
-                keypoint_data = [coord['x'], coord['y']]
-
-        tools_data['keypoint'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': keypoint_data,  # Format: [x, y]
-        })
-
-    def _convert_3d_bounding_box(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process 3D bounding box annotation.
+        annotations = v1_data.get('annotations', {})
+        annotations_data = v1_data.get('annotationsData', {})
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
-        """
-        if '3d_bounding_box' not in tools_data:
-            tools_data['3d_bounding_box'] = []
-
-        # Process 3d_bounding_box psr (position, scale, rotation)
-        psr_data = {}
-        if 'psr' in item and isinstance(item['psr'], dict):
-            psr = item['psr']
-
-            # Extract only x, y, z values from position, scale, rotation
-            for component in ['position', 'scale', 'rotation']:
-                if component in psr and isinstance(psr[component], dict):
-                    psr_data[component] = {
-                        'x': psr[component].get('x'),
-                        'y': psr[component].get('y'),
-                        'z': psr[component].get('z'),
-                    }
-
-        tools_data['3d_bounding_box'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': psr_data,  # Format: {position: {x,y,z}, scale: {x,y,z}, rotation: {x,y,z}}
-        })
-
-    def _convert_video_segmentation_data(
-        self, item, item_id, classification, tools_data, id_to_full_classification=None
-    ):
-        """Process video segmentation annotation data.
+        # Build classification map
+        classification_map = self._build_classification_map(annotations)
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
-        """
-        if 'segmentation' not in tools_data:
-            tools_data['segmentation'] = []
-
-        # Process frame section-based segmentation (videos)
-        segmentation_data = {}
-        if 'section' in item and isinstance(item['section'], dict):
-            segmentation_data = item['section']
-
-        tools_data['segmentation'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': segmentation_data,  # Format: {startFrame: x, endFrame: y}
-        })
-
-    def _convert_image_segmentation_data(
-        self, item, item_id, classification, tools_data, id_to_full_classification=None
-    ):
-        """Process image segmentation annotation data.
+        # Convert annotations by media type
+        result: V2AnnotationData = {
+            'classification': classification_map,
+        }
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
-        """
-        if 'segmentation' not in tools_data:
-            tools_data['segmentation'] = []
+        # Process by media ID
+        for media_id, ann_list in annotations.items():
+            # Detect media type
+            singular_type, plural_type = self._extract_media_type_info(media_id)
 
-        # Process pixel-based segmentation (images)
-        segmentation_data = {}
-        if 'pixel_indices' in item and isinstance(item['pixel_indices'], list):
-            segmentation_data = item['pixel_indices']
+            # Initialize media type array
+            if plural_type not in result:
+                result[plural_type] = []
 
-        tools_data['segmentation'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': segmentation_data,  # Format: [pixel_indices...]
-        })
+            # Convert media item
+            media_item = self._convert_media_item(media_id, ann_list, annotations_data.get(media_id, []))
 
-    def _process_polygon_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process polygon annotation.
+            result[plural_type].append(media_item)
 
-        Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
-        """
-        if 'polygon' not in tools_data:
-            tools_data['polygon'] = []
-
-        # Process polygon coordinates
-        polygon_data = []
-        if 'coordinate' in item and isinstance(item['coordinate'], list):
-            # Convert each coordinate point to [x, y] format
-            for point in item['coordinate']:
-                if 'x' in point and 'y' in point:
-                    polygon_data.append([point['x'], point['y']])
-
-        tools_data['polygon'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': polygon_data,  # Format: [[x1, y1], [x2, y2], [x3, y3], ...]
-        })
-
-    def _process_relation_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process relation annotation.
+        return result
+
+    def _build_annotation_meta(self, v1_data: dict[str, Any]) -> AnnotationMeta:
+        """Create annotation_meta (V1 top-level structure) from V1 data
 
         Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
+            v1_data: Complete V1 data
+
+        Returns:
+            V1 top-level structure (preserved as-is)
         """
-        if 'relation' not in tools_data:
-            tools_data['relation'] = []
+        return {
+            'extra': v1_data.get('extra', {}),
+            'annotations': v1_data.get('annotations', {}),
+            'annotationsData': v1_data.get('annotationsData', {}),
+            'relations': v1_data.get('relations', {}),
+            'annotationGroups': v1_data.get('annotationGroups', {}),
+            'assignmentId': v1_data.get('assignmentId'),
+        }
 
-        # Process relation data (needs adjustment based on actual relation data structure)
-        relation_data = []
-        if 'data' in item:
-            relation_data = item['data']
+    def _build_classification_map(self, annotations: dict[str, list[dict[str, Any]]]) -> dict[str, list[str]]:
+        """Build classification map from annotations
 
-        tools_data['relation'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': relation_data,  # Format: ['from_id', 'to_id']
-        })
+        Args:
+            annotations: V1 annotations data
 
-    def _convert_group(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process group annotation.
+        Returns:
+            Class label map by tool
+            e.g., {"bounding_box": ["person", "car"], "polygon": ["road"]}
+        """
+        classification_map: dict[str, set[str]] = {}
+
+        for media_id, ann_list in annotations.items():
+            for ann in ann_list:
+                tool = ann.get('tool', '')
+                classification_obj = ann.get('classification') or {}
+                class_label = classification_obj.get('class', '')
+
+                if tool and class_label:
+                    if tool not in classification_map:
+                        classification_map[tool] = set()
+                    classification_map[tool].add(class_label)
+
+        # Convert set to list
+        return {tool: sorted(list(labels)) for tool, labels in classification_map.items()}
+
+    def _convert_media_item(
+        self,
+        media_id: str,
+        annotations: list[dict[str, Any]],
+        annotations_data: list[dict[str, Any]],
+    ) -> dict[str, list[dict[str, Any]]]:
+        """Convert annotations for a single media item
 
         Args:
-            item (dict): Annotation item data
-            item_id (str): ID of the annotation item
-            classification (str): Classification label
-            tools_data (dict): Dictionary to store processed tool data
-            id_to_full_classification (dict, optional): Full classification mapping
+            media_id: Media ID
+            annotations: V1 annotations for this media
+            annotations_data: V1 annotationsData for this media
+
+        Returns:
+            V2 annotations grouped by tool
         """
-        if 'group' not in tools_data:
-            tools_data['group'] = []
-
-        # Process group data (needs adjustment based on actual group data structure)
-        group_data = []
-        if 'data' in item:
-            group_data = item['data']
-
-        tools_data['group'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': [],
-            'data': group_data,  # Format: ['id1', 'id2', 'id3', ...]
-        })
-
-    # Include all the _convert_* methods from previous code...
-    def _convert_classification(self, item, item_id, classification, tools_data, id_to_full_classification):
-        """Process classification annotation."""
-        if 'classification' not in tools_data:
-            tools_data['classification'] = []
-
-        # Get full classification info (including additional attributes)
-        full_classification = id_to_full_classification.get(item_id, {})
-
-        # Store additional attributes in attrs array
-        attrs = []
-        classification_data = {}
-
-        for key, value in full_classification.items():
-            if key != 'class':  # class is already stored in classification field
-                if isinstance(value, list) and len(value) > 0:
-                    # Array attributes like multiple
-                    attrs.append({'name': key, 'value': value})
-                elif isinstance(value, str) and value.strip():
-                    # String attributes like text, single_radio, single_dropdown
-                    attrs.append({'name': key, 'value': value})
-
-        tools_data['classification'].append({
-            'id': item_id,
-            'classification': classification,
-            'attrs': attrs,
-            'data': classification_data,  # Empty object for full text classification
-        })
-
-    def _convert_prompt(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process prompt annotation."""
-        if 'prompt' not in tools_data:
-            tools_data['prompt'] = []
-
-        # Process prompt input data from annotationsData
-        prompt_data = {}
-        attrs = []
-
-        if 'input' in item and isinstance(item['input'], list):
-            # Store complete input structure
-            input_items = []
-            for input_item in item['input']:
-                if isinstance(input_item, dict):
-                    input_items.append(input_item)
-                    # Extract text value for easy access
-                    if input_item.get('type') == 'text' and 'value' in input_item:
-                        prompt_data['text'] = input_item['value']
-                        attrs.append('text')
-
-            prompt_data['input'] = input_items
-            attrs.append('input')
-
-        # Include any additional metadata
-        for key in ['model', 'displayName', 'generatedBy', 'timestamp']:
-            if key in item:
-                prompt_data[key] = item[key]
-                attrs.append(key)
-
-        result_item = {
-            'id': item_id,
-            'classification': classification,
-            'attrs': attrs,
-            'data': prompt_data,  # Format: {text: "prompt text", input: [...], ...}
-        }
-        tools_data['prompt'].append(result_item)
-
-    def _convert_answer(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process answer annotation."""
-        if 'answer' not in tools_data:
-            tools_data['answer'] = []
-
-        # Process answer output data from annotationsData
-        answer_data = {}
-        attrs = []
-
-        if 'output' in item and isinstance(item['output'], list):
-            # Store complete output structure
-            output_items = []
-            for output_item in item['output']:
-                if isinstance(output_item, dict):
-                    output_items.append(output_item)
-                    # Extract text value for easy access
-                    if output_item.get('type') == 'text' and 'value' in output_item:
-                        answer_data['text'] = output_item['value']
-                        attrs.append('text')
-
-            answer_data['output'] = output_items
-            attrs.append('output')
-
-        # Include all additional metadata from annotationsData
-        metadata_fields = ['model', 'displayName', 'generatedBy', 'promptAnnotationId', 'timestamp', 'primaryKey']
-        for key in metadata_fields:
-            if key in item:
-                answer_data[key] = item[key]
-                attrs.append(key)
-
-        result_item = {
-            'id': item_id,
-            'classification': classification,
-            'attrs': attrs,
-            'data': answer_data,  # Format: {text: "answer text", output: [...], model: "...", ...}
-        }
+        # Create ID → annotationData mapping
+        data_by_id = {item['id']: item for item in annotations_data if 'id' in item}
 
-        tools_data['answer'].append(result_item)
+        # Group by tool
+        result: dict[str, list[dict[str, Any]]] = {}
 
-    def _convert_3d_segmentation(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process 3D segmentation annotation."""
-        if '3d_segmentation' not in tools_data:
-            tools_data['3d_segmentation'] = []
+        for ann in annotations:
+            ann_id = ann.get('id', '')
+            tool = ann.get('tool', '')
 
-        # Process 3D segmentation point data from annotationsData
-        segmentation_data = {}
-        attrs = []
+            if not tool:
+                continue
 
-        if 'points' in item and isinstance(item['points'], list):
-            segmentation_data['points'] = item['points']
-            attrs.append('points')
+            # Get processor
+            processor = self.get_processor(tool)
+            if not processor:
+                # Raise error for unsupported tool
+                supported_tools = list(self._tool_processors.keys())
+                raise ValueError(f"Unsupported tool: '{tool}'. Supported tools: {', '.join(sorted(supported_tools))}")
 
-        # Include any additional metadata
-        for key in ['tool']:
-            if key in item:
-                segmentation_data[key] = item[key]
-                attrs.append(key)
+            # Find annotationData for this ID
+            ann_data = data_by_id.get(ann_id, {})
 
-        result_item = {
-            'id': item_id,
-            'classification': classification,
-            'attrs': attrs,
-            'data': segmentation_data,  # Format: {points: [146534, 146662, ...], ...}
-        }
-        tools_data['3d_segmentation'].append(result_item)
-
-    def _convert_polygon(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process polygon annotation."""
-        return self._process_polygon_common(item, item_id, classification, tools_data, id_to_full_classification)
-
-    def _convert_polyline(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process polyline annotation."""
-        return self._process_polyline_common(item, item_id, classification, tools_data, id_to_full_classification)
-
-    def _convert_keypoint(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process keypoint annotation."""
-        return self._process_keypoint_common(item, item_id, classification, tools_data, id_to_full_classification)
-
-    # Segmentation methods
-    def _convert_image_segmentation(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process segmentation annotation for image."""
-        return self._convert_image_segmentation_data(
-            item, item_id, classification, tools_data, id_to_full_classification
-        )
-
-    def _convert_video_segmentation(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process segmentation annotation for video."""
-        return self._convert_video_segmentation_data(
-            item, item_id, classification, tools_data, id_to_full_classification
-        )
-
-    def _convert_relation(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process relation annotation."""
-        return self._process_relation_common(item, item_id, classification, tools_data, id_to_full_classification)
+            # Convert to V2
+            v2_annotation = processor.to_v2(ann, ann_data)
+
+            # Group by tool
+            if tool not in result:
+                result[tool] = []
+            result[tool].append(v2_annotation)
+
+        return result