synapse-sdk 1.0.0a79__py3-none-any.whl → 1.0.0a81__py3-none-any.whl

synapse_sdk/utils/converters/dm/from_v1.py

@@ -4,13 +4,14 @@ from . import BaseDMConverter
 class DMV1ToV2Converter(BaseDMConverter):
     """DM v1 to v2 format converter class."""
 
-    def __init__(self, old_dm_data={}):
+    def __init__(self, old_dm_data={}, file_type=None):
         """Initialize the converter.
 
         Args:
             old_dm_data (dict): DM v1 format data to be converted
+            file_type (str, optional): Type of file being converted
         """
-        super().__init__()
+        super().__init__(file_type)
         self.old_dm_data = old_dm_data
         self.classification_info = {}
         self.media_data = {}
@@ -29,8 +30,16 @@ class DMV1ToV2Converter(BaseDMConverter):
         # Extract media IDs from annotations key
         media_ids = list(old_dm_data.get('annotations', {}).keys())
 
+        # 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()
+
         for media_id in media_ids:
-            self._process_media_item(old_dm_data, media_id)
+            self._convert_media_item(old_dm_data, media_id)
 
         # Build final result (put classification at the front)
         result = {'classification': self.classification_info}
@@ -38,7 +47,13 @@ class DMV1ToV2Converter(BaseDMConverter):
 
         return result
 
-    def _process_media_item(self, old_dm_data, media_id):
+    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
+
+    def _convert_media_item(self, old_dm_data, media_id):
         """Process a single media item.
 
         Args:
@@ -53,17 +68,28 @@ class DMV1ToV2Converter(BaseDMConverter):
             self.media_data[media_type_plural] = []
 
         # Create id -> class and tool mappings
-        id_to_class = {
-            annotation['id']: annotation['classification']['class']
-            for annotation in old_dm_data['annotations'][media_id]
-        }
+        annotations = old_dm_data.get('annotations', {}).get(media_id, [])
 
-        id_to_tool = {annotation['id']: annotation['tool'] for annotation in old_dm_data['annotations'][media_id]}
+        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']
 
         # Create id -> full classification mapping (including additional attributes)
-        id_to_full_classification = {
-            annotation['id']: annotation['classification'] for annotation in old_dm_data['annotations'][media_id]
-        }
+        id_to_full_classification = {annotation['id']: annotation['classification'] for annotation in annotations}
+
+        # Collect all classifications from annotations (regardless of whether they have data)
+        for annotation in annotations:
+            tool_type = annotation['tool']
+            classification = annotation['classification']['class']
+
+            if tool_type not in self.classification_info:
+                self.classification_info[tool_type] = []
+
+            # Add only non-duplicate classifications
+            if classification and classification not in self.classification_info[tool_type]:
+                self.classification_info[tool_type].append(classification)
 
         # Initialize current media item
         media_item = {}
@@ -80,17 +106,9 @@ class DMV1ToV2Converter(BaseDMConverter):
             tool_type = id_to_tool.get(item_id, '')
             classification = id_to_class.get(item_id, '')
 
-            # Collect classification info (maintain existing ID)
-            if tool_type not in self.classification_info:
-                self.classification_info[tool_type] = []
-
-            # Add only non-duplicate classifications
-            if classification and classification not in self.classification_info[tool_type]:
-                self.classification_info[tool_type].append(classification)
-
             # Process by each tool type
-            self._process_annotation_item(
-                item, item_id, tool_type, classification, id_to_full_classification, tools_data
+            self._convert_annotation_item(
+                item, item_id, tool_type, classification, id_to_full_classification, tools_data, media_type
             )
 
         # Add processed tool data to media item
@@ -102,8 +120,10 @@ class DMV1ToV2Converter(BaseDMConverter):
         if media_item:
             self.media_data[media_type_plural].append(media_item)
 
-    def _process_annotation_item(self, item, item_id, tool_type, classification, id_to_full_classification, tools_data):
-        """Process a single annotation item based on its tool type.
+    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.
 
         Args:
             item (dict): Annotation item data
@@ -112,16 +132,45 @@ class DMV1ToV2Converter(BaseDMConverter):
             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)
         """
-        processor = self.tool_processors.get(tool_type)
-        if processor:
-            processor(item, item_id, classification, tools_data, id_to_full_classification)
+        # 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:
-            # Handle unknown tool_type
-            self._handle_unknown_tool(tool_type, item_id)
-
-    def _process_bounding_box(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process bounding box annotation.
+            # 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.
 
         Args:
             item (dict): Annotation item data
@@ -161,7 +210,11 @@ class DMV1ToV2Converter(BaseDMConverter):
                 'data': data,
             })
 
-    def _process_named_entity(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    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.
 
         Args:
@@ -191,43 +244,7 @@ class DMV1ToV2Converter(BaseDMConverter):
             'data': entity_data,  # Format: {ranges: [...], content: "..."}
         })
 
-    def _process_classification(self, item, item_id, classification, tools_data, id_to_full_classification):
-        """Process classification annotation.
-
-        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): Full classification mapping
-        """
-        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 _process_polyline(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    def _process_polyline_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
         """Process polyline annotation.
 
         Args:
@@ -246,16 +263,16 @@ class DMV1ToV2Converter(BaseDMConverter):
             # Convert each coordinate point to [x, y] format
             for point in item['coordinate']:
                 if 'x' in point and 'y' in point:
-                    polyline_data.extend([point['x'], point['y']])
+                    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, ...]
+            'data': polyline_data,  # Format: [[x1, y1], [x2, y2], [x3, y3], ...]
         })
 
-    def _process_keypoint(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    def _process_keypoint_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
         """Process keypoint annotation.
 
         Args:
@@ -282,7 +299,7 @@ class DMV1ToV2Converter(BaseDMConverter):
             'data': keypoint_data,  # Format: [x, y]
         })
 
-    def _process_3d_bounding_box(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    def _convert_3d_bounding_box(self, item, item_id, classification, tools_data, id_to_full_classification=None):
         """Process 3D bounding box annotation.
 
         Args:
@@ -298,7 +315,16 @@ class DMV1ToV2Converter(BaseDMConverter):
         # Process 3d_bounding_box psr (position, scale, rotation)
         psr_data = {}
         if 'psr' in item and isinstance(item['psr'], dict):
-            psr_data = item['psr']
+            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,
@@ -307,8 +333,37 @@ class DMV1ToV2Converter(BaseDMConverter):
             'data': psr_data,  # Format: {position: {x,y,z}, scale: {x,y,z}, rotation: {x,y,z}}
         })
 
-    def _process_segmentation(self, item, item_id, classification, tools_data, id_to_full_classification=None):
-        """Process segmentation annotation.
+    def _convert_video_segmentation_data(
+        self, item, item_id, classification, tools_data, id_to_full_classification=None
+    ):
+        """Process video segmentation annotation 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 '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.
 
         Args:
             item (dict): Annotation item data
@@ -320,23 +375,19 @@ class DMV1ToV2Converter(BaseDMConverter):
         if 'segmentation' not in tools_data:
             tools_data['segmentation'] = []
 
-        # Process segmentation pixel_indices or section
+        # Process pixel-based segmentation (images)
         segmentation_data = {}
         if 'pixel_indices' in item and isinstance(item['pixel_indices'], list):
-            # Pixel-based segmentation (images)
             segmentation_data = item['pixel_indices']
-        elif 'section' in item and isinstance(item['section'], dict):
-            # Frame section-based segmentation (videos)
-            segmentation_data = item['section']
 
         tools_data['segmentation'].append({
             'id': item_id,
             'classification': classification,
             'attrs': [],
-            'data': segmentation_data,  # Format: [pixel_indices...] or {startFrame: x, endFrame: y}
+            'data': segmentation_data,  # Format: [pixel_indices...]
         })
 
-    def _process_polygon(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    def _process_polygon_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
         """Process polygon annotation.
 
         Args:
@@ -355,16 +406,16 @@ class DMV1ToV2Converter(BaseDMConverter):
             # Convert each coordinate point to [x, y] format
             for point in item['coordinate']:
                 if 'x' in point and 'y' in point:
-                    polygon_data.extend([point['x'], point['y']])
+                    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, ...]
+            'data': polygon_data,  # Format: [[x1, y1], [x2, y2], [x3, y3], ...]
         })
 
-    def _process_relation(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    def _process_relation_common(self, item, item_id, classification, tools_data, id_to_full_classification=None):
         """Process relation annotation.
 
         Args:
@@ -389,7 +440,7 @@ class DMV1ToV2Converter(BaseDMConverter):
             'data': relation_data,  # Format: ['from_id', 'to_id']
         })
 
-    def _process_group(self, item, item_id, classification, tools_data, id_to_full_classification=None):
+    def _convert_group(self, item, item_id, classification, tools_data, id_to_full_classification=None):
         """Process group annotation.
 
         Args:
@@ -413,3 +464,164 @@ class DMV1ToV2Converter(BaseDMConverter):
             '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: "...", ...}
+        }
+
+        tools_data['answer'].append(result_item)
+
+    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'] = []
+
+        # Process 3D segmentation point data from annotationsData
+        segmentation_data = {}
+        attrs = []
+
+        if 'points' in item and isinstance(item['points'], list):
+            segmentation_data['points'] = item['points']
+            attrs.append('points')
+
+        # Include any additional metadata
+        for key in ['tool']:
+            if key in item:
+                segmentation_data[key] = item[key]
+                attrs.append(key)
+
+        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)