synapse-sdk 1.0.0a80__tar.gz → 1.0.0a82__tar.gz

{synapse_sdk-1.0.0a80 → synapse_sdk-1.0.0a82}/PKG-INFO

@@ -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 → synapse_sdk-1.0.0a82}/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-1.0.0a80 → synapse_sdk-1.0.0a82}/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-1.0.0a82/synapse_sdk/shared/enums.py

@@ -0,0 +1,69 @@
+from enum import Enum
+
+
+class Context(str, Enum):
+    INFO = 'info'
+    SUCCESS = 'success'
+    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-1.0.0a82/synapse_sdk/utils/converters/dm/__init__.py

@@ -0,0 +1,57 @@
+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 = SupportedTools.get_all_values()
+
+    def __init__(self, file_type=None):
+        """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 dynamically based on file_type."""
+        if not self.file_type:
+            return {}
+
+        processors = {}
+        tools = SupportedTools.get_tools_for_file_type(self.file_type)
+
+        for tool in tools:
+            # For other tools, use generic method names
+            method_name = f'_convert_{tool.method_name}'
+
+            if hasattr(self, method_name):
+                processors[tool.annotation_tool] = getattr(self, method_name)
+
+        return processors
+
+    @abstractmethod
+    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."""
+        warning_msg = f"Warning: Unknown tool type '{tool_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')