synapse-sdk 1.0.0a80__py3-none-any.whl → 1.0.0a82__py3-none-any.whl

synapse_sdk/plugins/categories/pre_annotation/actions/to_task.py

@@ -381,14 +381,22 @@ class ToTaskAction(Action):
         files = data_unit.get('files', {})
         data_file = files.get(target_specification_name)
 
+        # Extract primary file URL from task data
+        primary_file_url = self._extract_primary_file_url(task)
+        if not primary_file_url:
+            error_msg = 'Primary image URL not found in task data'
+            self.run.log_message(f'{error_msg} for task {task_id}')
+            self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+            return {'success': False, 'error': error_msg}
+
         if not data_file:
             error_msg = 'File specification not found'
             self.run.log_message(f'{error_msg} for task {task_id}')
             self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
             return {'success': False, 'error': error_msg}
 
-        url = data_file.get('url')
-        if not url:
+        data_file_url = data_file.get('url')
+        if not data_file_url:
             error_msg = 'URL not found'
             self.run.log_message(f'{error_msg} for task {task_id}')
             self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
@@ -396,32 +404,27 @@ class ToTaskAction(Action):
 
         # Fetch and process the data
         try:
-            response = requests.get(url)
-            response.raise_for_status()
-            data = json.loads(response.content)
-
             # Convert data to task object
             annotation_to_task = self.entrypoint(self.run)
-            converted_data = annotation_to_task.convert_data_from_file(data)
-
-            # Submit annotation data
-            client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_data})
-
-            # Log success
-            self.run.log_annotate_task_data({'task_id': task_id, 'url': url}, AnnotateTaskDataStatus.SUCCESS)
-            return {'success': True}
-
+            converted_data = annotation_to_task.convert_data_from_file(primary_file_url, data_file_url)
         except requests.RequestException as e:
             error_msg = f'Failed to fetch data from URL: {str(e)}'
             self.run.log_message(f'{error_msg} for task {task_id}')
             self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
             return {'success': False, 'error': error_msg}
-        except json.JSONDecodeError as e:
-            error_msg = f'Failed to parse JSON data: {str(e)}'
+        except Exception as e:
+            error_msg = f'Failed to convert data to task object: {str(e)}'
             self.run.log_message(f'{error_msg} for task {task_id}')
             self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
             return {'success': False, 'error': error_msg}
 
+        # Submit annotation data
+        client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_data})
+
+        # Log success
+        self.run.log_annotate_task_data({'task_id': task_id}, AnnotateTaskDataStatus.SUCCESS)
+        return {'success': True}
+
     def _process_single_task_with_inference(
         self, client: BackendClient, task_id: int, task: Dict[str, Any]
     ) -> Dict[str, Any]:

synapse_sdk/plugins/categories/pre_annotation/templates/plugin/to_task.py

@@ -7,18 +7,26 @@ class AnnotationToTask:
         """
         self.run = run
 
-    def convert_data_from_file(self, data: dict):
+    def convert_data_from_file(self, primary_file_url: str, data_file_url: str) -> dict:
         """Convert the data from a file to a task object.
 
         Args:
-            data: Converted data.
+            primary_file_url (str): primary file url.
+            data_file_url (str): data file url.
+
+        Returns:
+            dict: The converted data.
         """
-        return data
+        converted_data = {}
+        return converted_data
 
-    def convert_data_from_inference(self, data: dict):
+    def convert_data_from_inference(self, data: dict) -> dict:
         """Convert the data from inference result to a task object.
 
         Args:
             data: Converted data.
+
+        Returns:
+            dict: The converted data.
         """
         return data

synapse_sdk/shared/enums.py

@@ -7,3 +7,63 @@ class Context(str, Enum):
     WARNING = 'warning'
     DANGER = 'danger'
     ERROR = 'error'
+
+
+class SupportedTools(Enum):
+    """Enum for supported annotation tools.
+
+    * TODO: Need dynamic configuration by referencing apps/annotation/categories/{file_type}/settings.py.
+        * Currently difficult to configure due to non-standardized prompt file types.
+    """
+
+    BOUNDING_BOX = 'bounding_box', 'bounding_box'
+    NAMED_ENTITY = 'named_entity', 'named_entity'
+    CLASSIFICATION = 'classification', 'classification'
+    POLYLINE = 'polyline', 'polyline'
+    KEYPOINT = 'keypoint', 'keypoint'
+    BOUNDING_BOX_3D = '3d_bounding_box', '3d_bounding_box'
+    IMAGE_SEGMENTATION = 'segmentation', 'image_segmentation'
+    VIDEO_SEGMENTATION = 'segmentation', 'video_segmentation'
+    SEGMENTATION_3D = '3d_segmentation', '3d_segmentation'
+    POLYGON = 'polygon', 'polygon'
+    RELATION = 'relation', 'relation'
+    GROUP = 'group', 'group'
+    PROMPT = 'prompt', 'prompt'
+    ANSWER = 'answer', 'answer'
+
+    def __init__(self, annotation_tool, method_name):
+        self.annotation_tool = annotation_tool
+        self.method_name = method_name
+
+    @classmethod
+    def get_all_values(cls):
+        """Get all tool values as a list."""
+        return [tool.value for tool in cls]
+
+    @classmethod
+    def get_tools_for_file_type(cls, file_type):
+        """Get tools supported for a specific file type."""
+        basic_tools = [cls.RELATION, cls.GROUP, cls.CLASSIFICATION]
+
+        if file_type == 'image':
+            basic_tools.extend([
+                cls.BOUNDING_BOX,
+                cls.POLYLINE,
+                cls.KEYPOINT,
+                cls.IMAGE_SEGMENTATION,
+                cls.POLYGON,
+            ])
+        elif file_type == 'video':
+            basic_tools.extend([
+                cls.BOUNDING_BOX,
+                cls.POLYLINE,
+                cls.KEYPOINT,
+                cls.VIDEO_SEGMENTATION,
+                cls.POLYGON,
+            ])
+        elif file_type == 'pcd':
+            basic_tools.extend([cls.BOUNDING_BOX_3D, cls.SEGMENTATION_3D])
+        elif file_type == 'text':
+            basic_tools.extend([cls.PROMPT, cls.ANSWER, cls.NAMED_ENTITY])
+
+        return basic_tools

synapse_sdk/utils/converters/dm/__init__.py

@@ -1,95 +1,43 @@
 from abc import ABC, abstractmethod
+from enum import Enum
+
+from synapse_sdk.shared.enums import SupportedTools
 
 
 class BaseDMConverter(ABC):
     """Base class for DM format converters."""
 
-    SUPPORTED_TOOLS = [
-        'bounding_box',
-        'named_entity',
-        'classification',
-        'polyline',
-        'keypoint',
-        '3d_bounding_box',
-        'segmentation',
-        'polygon',
-        'relation',
-        'group',
-    ]
+    SUPPORTED_TOOLS = SupportedTools.get_all_values()
+
+    def __init__(self, file_type=None):
+        """Initialize the base converter.
 
-    def __init__(self):
-        """Initialize the base converter."""
+        Args:
+            file_type (str, optional): Type of file being converted (image, video, pcd, text, audio)
+        """
+        self.file_type = file_type
         self.tool_processors = self._setup_tool_processors()
 
     def _setup_tool_processors(self):
-        """Setup tool processor mapping."""
-        return {
-            'bounding_box': self._process_bounding_box,
-            'named_entity': self._process_named_entity,
-            'classification': self._process_classification,
-            'polyline': self._process_polyline,
-            'keypoint': self._process_keypoint,
-            '3d_bounding_box': self._process_3d_bounding_box,
-            'segmentation': self._process_segmentation,
-            'polygon': self._process_polygon,
-            'relation': self._process_relation,
-            'group': self._process_group,
-        }
-
-    @abstractmethod
-    def convert(self):
-        """Convert data from one format to another."""
-        pass
-
-    @abstractmethod
-    def _process_bounding_box(self, *args, **kwargs):
-        """Process bounding box annotation."""
-        pass
-
-    @abstractmethod
-    def _process_named_entity(self, *args, **kwargs):
-        """Process named entity annotation."""
-        pass
-
-    @abstractmethod
-    def _process_classification(self, *args, **kwargs):
-        """Process classification annotation."""
-        pass
+        """Setup tool processor mapping dynamically based on file_type."""
+        if not self.file_type:
+            return {}
 
-    @abstractmethod
-    def _process_polyline(self, *args, **kwargs):
-        """Process polyline annotation."""
-        pass
+        processors = {}
+        tools = SupportedTools.get_tools_for_file_type(self.file_type)
 
-    @abstractmethod
-    def _process_keypoint(self, *args, **kwargs):
-        """Process keypoint annotation."""
-        pass
+        for tool in tools:
+            # For other tools, use generic method names
+            method_name = f'_convert_{tool.method_name}'
 
-    @abstractmethod
-    def _process_3d_bounding_box(self, *args, **kwargs):
-        """Process 3D bounding box annotation."""
-        pass
+            if hasattr(self, method_name):
+                processors[tool.annotation_tool] = getattr(self, method_name)
 
-    @abstractmethod
-    def _process_segmentation(self, *args, **kwargs):
-        """Process segmentation annotation."""
-        pass
+        return processors
 
     @abstractmethod
-    def _process_polygon(self, *args, **kwargs):
-        """Process polygon annotation."""
-        pass
-
-    @abstractmethod
-    def _process_relation(self, *args, **kwargs):
-        """Process relation annotation."""
-        pass
-
-    @abstractmethod
-    def _process_group(self, *args, **kwargs):
-        """Process group annotation."""
-        pass
+    def convert(self):
+        """Convert data from one format to another."""
 
     def _handle_unknown_tool(self, tool_type, item_id=None):
         """Handle unknown tool types with consistent warning message."""

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)

synapse_sdk/utils/converters/dm/to_v1.py

@@ -7,13 +7,18 @@ from . import BaseDMConverter
 class DMV2ToV1Converter(BaseDMConverter):
     """DM v2 to v1 format converter class."""
 
-    def __init__(self, new_dm_data={}):
+    def __init__(self, new_dm_data={}, file_type=None):
         """Initialize the converter.
 
         Args:
             new_dm_data (dict): DM v2 format data to be converted
+            file_type (str, optional): Type of file being converted (image, video, pcd, text, audio)
         """
-        super().__init__()
+        # Auto-detect file type if not provided
+        if file_type is None:
+            file_type = self._detect_file_type(new_dm_data)
+
+        super().__init__(file_type=file_type)
         self.new_dm_data = new_dm_data
         self.annotations = {}
         self.annotations_data = {}
@@ -21,6 +26,32 @@ class DMV2ToV1Converter(BaseDMConverter):
         self.relations = {}
         self.annotation_groups = {}
 
+    def _detect_file_type(self, data):
+        """Auto-detect file type from the data structure.
+
+        Args:
+            data (dict): DM v2 format data
+
+        Returns:
+            str: Detected file type (image, video, pcd, text, audio)
+        """
+        if not data:
+            return None
+
+        # Check for media type keys (plural forms)
+        if 'images' in data:
+            return 'image'
+        elif 'videos' in data:
+            return 'video'
+        elif 'pcds' in data:
+            return 'pcd'
+        elif 'texts' in data:
+            return 'text'
+        elif 'audios' in data:
+            return 'audio'
+
+        return None
+
     def convert(self):
         """Convert DM v2 data to v1 format.
 
@@ -110,7 +141,7 @@ class DMV2ToV1Converter(BaseDMConverter):
             else:
                 self._handle_unknown_tool(tool_type, annotation_id)
 
-    def _process_bounding_box(self, annotation_id, data, annotations_data):
+    def _convert_bounding_box(self, annotation_id, data, annotations_data):
         """Process bounding box annotation data.
 
         Args:
@@ -124,7 +155,7 @@ class DMV2ToV1Converter(BaseDMConverter):
 
             annotations_data.append({'id': annotation_id, 'coordinate': coordinate})
 
-    def _process_named_entity(self, annotation_id, data, annotations_data):
+    def _convert_named_entity(self, annotation_id, data, annotations_data):
         """Process named entity annotation data.
 
         Args:
@@ -142,7 +173,7 @@ class DMV2ToV1Converter(BaseDMConverter):
 
         annotations_data.append(entity_data)
 
-    def _process_classification(self, annotation_id, data, annotations_data):
+    def _convert_classification(self, annotation_id, data, annotations_data):
         """Process classification annotation data.
 
         Args:
@@ -153,23 +184,30 @@ class DMV2ToV1Converter(BaseDMConverter):
         # Classification data is typically empty in v2, so we just add the ID
         annotations_data.append({'id': annotation_id})
 
-    def _process_polyline(self, annotation_id, data, annotations_data):
+    def _convert_polyline(self, annotation_id, data, annotations_data):
         """Process polyline annotation data.
 
         Args:
             annotation_id (str): ID of the annotation
-            data (list): Polyline data [x1, y1, x2, y2, ...]
+            data (list): Polyline data - can be flat [x1, y1, x2, y2, ...] or nested [[x1, y1], [x2, y2], ...]
             annotations_data (list): List to append the processed data
         """
-        # Convert flat array to coordinate objects
         coordinates = []
-        for i in range(0, len(data), 2):
-            if i + 1 < len(data):
-                coordinates.append({'x': data[i], 'y': data[i + 1], 'id': self._generate_random_id()})
+
+        if data and isinstance(data[0], list):
+            # Nested format: [[x1, y1], [x2, y2], ...]
+            for point in data:
+                if len(point) >= 2:
+                    coordinates.append({'x': point[0], 'y': point[1], 'id': self._generate_random_id()})
+        else:
+            # Flat format: [x1, y1, x2, y2, ...]
+            for i in range(0, len(data), 2):
+                if i + 1 < len(data):
+                    coordinates.append({'x': data[i], 'y': data[i + 1], 'id': self._generate_random_id()})
 
         annotations_data.append({'id': annotation_id, 'coordinate': coordinates})
 
-    def _process_keypoint(self, annotation_id, data, annotations_data):
+    def _convert_keypoint(self, annotation_id, data, annotations_data):
         """Process keypoint annotation data.
 
         Args:
@@ -182,7 +220,7 @@ class DMV2ToV1Converter(BaseDMConverter):
 
             annotations_data.append({'id': annotation_id, 'coordinate': coordinate})
 
-    def _process_3d_bounding_box(self, annotation_id, data, annotations_data):
+    def _convert_3d_bounding_box(self, annotation_id, data, annotations_data):
         """Process 3D bounding box annotation data.
 
         Args:
@@ -192,7 +230,7 @@ class DMV2ToV1Converter(BaseDMConverter):
         """
         annotations_data.append({'id': annotation_id, 'psr': data})
 
-    def _process_segmentation(self, annotation_id, data, annotations_data):
+    def _convert_image_segmentation(self, annotation_id, data, annotations_data):
         """Process segmentation annotation data.
 
         Args:
@@ -211,23 +249,98 @@ class DMV2ToV1Converter(BaseDMConverter):
 
         annotations_data.append(annotation_data)
 
-    def _process_polygon(self, annotation_id, data, annotations_data):
+    def _convert_video_segmentation(self, annotation_id, data, annotations_data):
+        """Process video segmentation annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list or dict): Segmentation data (pixel_indices or section)
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, list):
+            # Pixel-based segmentation
+            annotation_data['pixel_indices'] = data
+        elif isinstance(data, dict):
+            # Section-based segmentation (video)
+            annotation_data['section'] = data
+
+        annotations_data.append(annotation_data)
+
+    def _convert_3d_segmentation(self, annotation_id, data, annotations_data):
+        """Process 3D segmentation annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (list or dict): 3D segmentation data
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, list):
+            # Pixel-based segmentation
+            annotation_data['pixel_indices'] = data
+        elif isinstance(data, dict):
+            # Section-based segmentation
+            annotation_data['section'] = data
+
+        annotations_data.append(annotation_data)
+
+    def _convert_prompt(self, annotation_id, data, annotations_data):
+        """Process prompt annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): Prompt data
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, dict):
+            annotation_data.update(data)
+
+        annotations_data.append(annotation_data)
+
+    def _convert_answer(self, annotation_id, data, annotations_data):
+        """Process answer annotation data.
+
+        Args:
+            annotation_id (str): ID of the annotation
+            data (dict): Answer data
+            annotations_data (list): List to append the processed data
+        """
+        annotation_data = {'id': annotation_id}
+
+        if isinstance(data, dict):
+            annotation_data.update(data)
+
+        annotations_data.append(annotation_data)
+
+    def _convert_polygon(self, annotation_id, data, annotations_data):
         """Process polygon annotation data.
 
         Args:
             annotation_id (str): ID of the annotation
-            data (list): Polygon data [x1, y1, x2, y2, ...]
+            data (list): Polygon data - can be flat [x1, y1, x2, y2, ...] or nested [[x1, y1], [x2, y2], ...]
             annotations_data (list): List to append the processed data
         """
-        # Convert flat array to coordinate objects
         coordinates = []
-        for i in range(0, len(data), 2):
-            if i + 1 < len(data):
-                coordinates.append({'x': data[i], 'y': data[i + 1], 'id': self._generate_random_id()})
+
+        if data and isinstance(data[0], list):
+            # Nested format: [[x1, y1], [x2, y2], ...]
+            for point in data:
+                if len(point) >= 2:
+                    coordinates.append({'x': point[0], 'y': point[1], 'id': self._generate_random_id()})
+        else:
+            # Flat format: [x1, y1, x2, y2, ...]
+            for i in range(0, len(data), 2):
+                if i + 1 < len(data):
+                    coordinates.append({'x': data[i], 'y': data[i + 1], 'id': self._generate_random_id()})
 
         annotations_data.append({'id': annotation_id, 'coordinate': coordinates})
 
-    def _process_relation(self, annotation_id, data, annotations_data):
+    def _convert_relation(self, annotation_id, data, annotations_data):
         """Process relation annotation data.
 
         Args:
@@ -237,7 +350,7 @@ class DMV2ToV1Converter(BaseDMConverter):
         """
         annotations_data.append({'id': annotation_id, 'data': data})
 
-    def _process_group(self, annotation_id, data, annotations_data):
+    def _convert_group(self, annotation_id, data, annotations_data):
         """Process group annotation data.
 
         Args:

synapse_sdk/utils/converters/pascal/to_dm.py

@@ -1,6 +1,6 @@
 import os
 import xml.etree.ElementTree as ET
-from typing import Any, Dict, IO, List, Optional, Tuple
+from typing import IO, Any, Dict, List, Optional, Tuple
 
 from PIL import Image
 

synapse_sdk/utils/converters/yolo/to_dm.py

@@ -11,10 +11,29 @@ class YOLOToDMConverter(ToDMConverter):
     """Convert YOLO formatted datasets to DM format."""
 
     IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
-
-    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+    CLASS_NAMES = []
+
+    def __init__(
+        self,
+        root_dir: str = None,
+        is_categorized_dataset: bool = False,
+        is_single_conversion: bool = False,
+        class_names: List[str] = None,
+    ):
         super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
 
+        # Set class names
+        self.CLASS_NAMES = class_names
+
+        # Get class names from dataset.yaml if not provided
+        if not class_names:
+            dataset_yaml_path = os.path.join(self.root_dir, 'dataset.yaml')
+            if not os.path.exists(dataset_yaml_path):
+                raise FileNotFoundError(f'No dataset.yaml file found in {self.root_dir}.')
+            with open(dataset_yaml_path, 'r', encoding='utf-8') as f:
+                dataset_yaml = yaml.safe_load(f)
+                self.CLASS_NAMES = dataset_yaml.get('names', [])
+
     def convert(self):
         """Convert YOLO dataset to DM format."""
         if self.is_categorized_dataset:
@@ -122,15 +141,6 @@ class YOLOToDMConverter(ToDMConverter):
         if not os.path.isdir(labels_dir):
             raise FileNotFoundError(f"No labels directory found in {split_dir} (expected 'labels').")
 
-        # Load dataset.yaml
-
-        dataset_yaml_path = os.path.join(self.root_dir, 'dataset.yaml')
-        if not os.path.exists(dataset_yaml_path):
-            raise FileNotFoundError(f'No dataset.yaml file found in {split_dir}.')
-        with open(dataset_yaml_path, 'r', encoding='utf-8') as f:
-            dataset_yaml = yaml.safe_load(f)
-            class_names = dataset_yaml.get('names', [])
-
         # Build DM data
         result = {}
         for label_filename in os.listdir(labels_dir):
@@ -156,7 +166,7 @@ class YOLOToDMConverter(ToDMConverter):
             }
 
             for line in label_lines:
-                ann = self._parse_yolo_line(line, class_names, img_size)
+                ann = self._parse_yolo_line(line, self.CLASS_NAMES, img_size)
                 if ann is None:
                     continue
 
@@ -187,13 +197,12 @@ class YOLOToDMConverter(ToDMConverter):
             result[os.path.basename(img_path)] = (dm_json, img_path)
         return result
 
-    def convert_single_file(self, data: List[str], original_file: IO, class_names: List[str]) -> Dict[str, Any]:
+    def convert_single_file(self, data: List[str], original_file: IO) -> Dict[str, Any]:
         """Convert a single YOLO label data and corresponding image to DM format.
 
         Args:
             data: List of YOLO label lines (strings from .txt file content)
             original_file: File object for the corresponding original image
-            class_names: List of class names corresponding to indices in the label data
 
         Returns:
             Dictionary containing DM format data for the single file
@@ -206,7 +215,7 @@ class YOLOToDMConverter(ToDMConverter):
             raise ValueError('original_file must have a "name" attribute representing its path or filename.')
 
         if hasattr(self, '_get_image_size'):
-            img_size = self._get_image_size(original_file)
+            img_size = self._get_image_size(img_path)
         else:
             raise AttributeError('Converter missing _get_image_size method for file objects.')
 
@@ -223,7 +232,7 @@ class YOLOToDMConverter(ToDMConverter):
         }
 
         for line in label_lines:
-            ann = self._parse_yolo_line(line, class_names, img_size)
+            ann = self._parse_yolo_line(line, self.CLASS_NAMES, img_size)
             if ann is None:
                 continue
 

{synapse_sdk-1.0.0a80.dist-info → synapse_sdk-1.0.0a82.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0a80
+Version: 1.0.0a82
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT

{synapse_sdk-1.0.0a80.dist-info → synapse_sdk-1.0.0a82.dist-info}/RECORD

@@ -152,11 +152,11 @@ synapse_sdk/plugins/categories/post_annotation/templates/plugin/post_annotation.
 synapse_sdk/plugins/categories/pre_annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/pre_annotation/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/pre_annotation/actions/pre_annotation.py,sha256=6ib3RmnGrjpsQ0e_G-mRH1lfFunQ3gh2M831vuDn7HU,344
-synapse_sdk/plugins/categories/pre_annotation/actions/to_task.py,sha256=EkKRId4zWVvqMFa2KxdAb3FaLtt3n5wz3rGkcVBltWY,31229
+synapse_sdk/plugins/categories/pre_annotation/actions/to_task.py,sha256=pmoOkDE5vidvlW_ZNabdOf7CuoRKZlQ0p_bvA7leCyw,31572
 synapse_sdk/plugins/categories/pre_annotation/templates/config.yaml,sha256=VREoCp9wsvZ8T2E1d_MEKlR8TC_herDJGVQtu3ezAYU,589
 synapse_sdk/plugins/categories/pre_annotation/templates/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/pre_annotation/templates/plugin/pre_annotation.py,sha256=HBHxHuv2gMBzDB2alFfrzI_SZ1Ztk6mo7eFbR5GqHKw,106
-synapse_sdk/plugins/categories/pre_annotation/templates/plugin/to_task.py,sha256=0j01vFZYkaAw8mtf6HYfun3IUDlryTexqvss_JZtc-Y,618
+synapse_sdk/plugins/categories/pre_annotation/templates/plugin/to_task.py,sha256=2lGOIAns1V8GWt-lUU-i9lpdk-AJ6vNY8s7Ks7a72BY,883
 synapse_sdk/plugins/categories/smart_tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/smart_tool/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/smart_tool/actions/auto_label.py,sha256=fHiqA8ntmzjs2GMVMuByR7Clh2zhLie8OPF9B8OmwxM,1279
@@ -187,7 +187,7 @@ synapse_sdk/plugins/utils/config.py,sha256=uyGp9GhphQE-b6sla3NwMUH0DeBunvi7szycR
 synapse_sdk/plugins/utils/legacy.py,sha256=UWEk5FHk_AqU4GxhfyKJ76VgBUHS-ktKV6_jTJCgT8k,2689
 synapse_sdk/plugins/utils/registry.py,sha256=HKALzYcPQSFsdLAzodYXMdfFnKOcg6oHYBrx7EwVqNU,1484
 synapse_sdk/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synapse_sdk/shared/enums.py,sha256=j90R9JblcBjaG1OPIVKiHPH_J2UvsBNSPc8Mp4Agv78,158
+synapse_sdk/shared/enums.py,sha256=t00jZvVxt6OY7Cp1c42oWTVwHWx8PzBiUqfDmhHlqVA,2282
 synapse_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/utils/dataset.py,sha256=zWTzFmv589izFr62BDuApi3r5FpTsdm-5AmriC0AEdM,1865
 synapse_sdk/utils/debug.py,sha256=F7JlUwYjTFZAMRbBqKm6hxOIz-_IXYA8lBInOS4jbS4,100
@@ -200,15 +200,15 @@ synapse_sdk/utils/converters/__init__.py,sha256=xQi_n7xS9BNyDiolsxH2jw1CtD6avxMP
 synapse_sdk/utils/converters/coco/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/utils/converters/coco/from_dm.py,sha256=B9zvb8Kph9haYLVIZhzneWiHCImFbuWqAaE7g6Nk0lI,11365
 synapse_sdk/utils/converters/coco/to_dm.py,sha256=YmD_NHKSUL8RZbzWX52FgDaJG0uX4I8f8Omp7ilhSec,9054
-synapse_sdk/utils/converters/dm/__init__.py,sha256=cHvpr4ljImnqeMvi5sevQiBD-R9ZHBWOpoKUUCiaGHE,3333
-synapse_sdk/utils/converters/dm/from_v1.py,sha256=wlFwGRD21nTAk0TVwFDxb-2w9Q9eQWJ1MBo-7CQcgKQ,16572
-synapse_sdk/utils/converters/dm/to_v1.py,sha256=jHeQoopht1lyPUsLK8T0xYK6aHVVYvS6JHiesSaPPk0,9430
+synapse_sdk/utils/converters/dm/__init__.py,sha256=_B6w814bMPhisNCNlSPEiQOs9RH0EZHQqd89LnVhD1U,1983
+synapse_sdk/utils/converters/dm/from_v1.py,sha256=4BG_NA_7YdW5rI1F8LCFg39M-IJZVfRgi2b9FBxTAmw,26059
+synapse_sdk/utils/converters/dm/to_v1.py,sha256=A123zAR_dLqEW83BgAl5_J1ACstjZWTHivlW5qvOu_E,13432
 synapse_sdk/utils/converters/pascal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/utils/converters/pascal/from_dm.py,sha256=AKOeQoyeSbSOawf-ya9dLx-pZP_MomNcDaCW5ka5_8Y,10378
-synapse_sdk/utils/converters/pascal/to_dm.py,sha256=JkA_OI_IR1ealZPe2uo4hFBcFyOh_VfeyIY43-R4IBA,8614
+synapse_sdk/utils/converters/pascal/to_dm.py,sha256=bQNUepahOCot4J23LCPOlFOhIZJ8cAK-pge23eJZETM,8614
 synapse_sdk/utils/converters/yolo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/utils/converters/yolo/from_dm.py,sha256=-JDCQLk4g1_FIVoOwZ1Tcs2kWFkhXRCAPVLKLXz6sLU,16180
-synapse_sdk/utils/converters/yolo/to_dm.py,sha256=UUGTbBNeG5Ao8PSJbizrZRQJfeAMuSDfZs8SGOyr-YU,10464
+synapse_sdk/utils/converters/yolo/to_dm.py,sha256=XcSkyPickvdPR2JZ-PMMPEf1-uWQL76_pO78-4aPYcQ,10614
 synapse_sdk/utils/pydantic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/utils/pydantic/config.py,sha256=1vYOcUI35GslfD1rrqhFkNXXJOXt4IDqOPSx9VWGfNE,123
 synapse_sdk/utils/pydantic/errors.py,sha256=0v0T12eQBr1KrFiEOBu6KMaPK4aPEGEC6etPJGoR5b4,1061
@@ -220,9 +220,9 @@ synapse_sdk/utils/storage/providers/gcp.py,sha256=i2BQCu1Kej1If9SuNr2_lEyTcr5M_n
 synapse_sdk/utils/storage/providers/http.py,sha256=2DhIulND47JOnS5ZY7MZUex7Su3peAPksGo1Wwg07L4,5828
 synapse_sdk/utils/storage/providers/s3.py,sha256=ZmqekAvIgcQBdRU-QVJYv1Rlp6VHfXwtbtjTSphua94,2573
 synapse_sdk/utils/storage/providers/sftp.py,sha256=_8s9hf0JXIO21gvm-JVS00FbLsbtvly4c-ETLRax68A,1426
-synapse_sdk-1.0.0a80.dist-info/licenses/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
-synapse_sdk-1.0.0a80.dist-info/METADATA,sha256=Z9-Wpg7L2jCgXLMrp_BaJ2Hjlg_IQMBCBOBcpLZZBnQ,3805
-synapse_sdk-1.0.0a80.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-synapse_sdk-1.0.0a80.dist-info/entry_points.txt,sha256=VNptJoGoNJI8yLXfBmhgUefMsmGI0m3-0YoMvrOgbxo,48
-synapse_sdk-1.0.0a80.dist-info/top_level.txt,sha256=ytgJMRK1slVOKUpgcw3LEyHHP7S34J6n_gJzdkcSsw8,12
-synapse_sdk-1.0.0a80.dist-info/RECORD,,
+synapse_sdk-1.0.0a82.dist-info/licenses/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
+synapse_sdk-1.0.0a82.dist-info/METADATA,sha256=tCCYQhZDkDvBXPSQa50Dzur5VrBpp9Hm7fWI6jHxFBA,3805
+synapse_sdk-1.0.0a82.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+synapse_sdk-1.0.0a82.dist-info/entry_points.txt,sha256=VNptJoGoNJI8yLXfBmhgUefMsmGI0m3-0YoMvrOgbxo,48
+synapse_sdk-1.0.0a82.dist-info/top_level.txt,sha256=ytgJMRK1slVOKUpgcw3LEyHHP7S34J6n_gJzdkcSsw8,12
+synapse_sdk-1.0.0a82.dist-info/RECORD,,