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

synapse_sdk/utils/converters/dm/tools/bounding_box.py

@@ -0,0 +1,132 @@
+"""
+Bounding Box Tool Processor
+
+Created: 2025-12-11
+
+Conversion Rules (see data-model.md 4.1):
+V1 → V2:
+  - coordinate.{x, y, width, height} → data[x, y, width, height]
+  - coordinate.rotation → attrs[{name:"rotation", value}]
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data[0,1,2,3] → coordinate.{x, y, width, height}
+  - attrs.rotation → coordinate.rotation
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value} (excluding special attrs)
+"""
+
+from typing import Any
+
+
+class BoundingBoxProcessor:
+    """Bounding Box Tool Processor
+
+    V1 coordinate: {x, y, width, height, rotation?}
+    V2 data: [x, y, width, height]
+    """
+
+    tool_name = 'bounding_box'
+
+    # V1 meta fields (not stored in attrs)
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+
+    # Fields to restore from V2 attrs to coordinate
+    _COORDINATE_ATTRS = {'rotation'}
+
+    # Special attrs not restored to V1 classification (_ prefix)
+    _INTERNAL_ATTR_PREFIX = '_'
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 bounding box to V2
+
+        Args:
+            v1_annotation: V1 annotations[] item
+            v1_data: V1 annotationsData[] item (same ID)
+
+        Returns:
+            V2 format bounding box annotation
+        """
+        coordinate = v1_data.get('coordinate', {})
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # V2 data: [x, y, width, height]
+        data = [
+            coordinate.get('x', 0),
+            coordinate.get('y', 0),
+            coordinate.get('width', 0),
+            coordinate.get('height', 0),
+        ]
+
+        # Build V2 attrs
+        attrs: list[dict[str, Any]] = []
+
+        # Add rotation to attrs
+        if 'rotation' in coordinate:
+            attrs.append({'name': 'rotation', 'value': coordinate['rotation']})
+
+        # Add other classification properties to attrs (excluding class)
+        for key, value in classification_obj.items():
+            if key != 'class':
+                attrs.append({'name': key, 'value': value})
+
+        # Build V2 annotation
+        return {
+            'id': v1_annotation.get('id', ''),
+            'classification': classification_obj.get('class', ''),
+            'attrs': attrs,
+            'data': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 bounding box to V1
+
+        Args:
+            v2_annotation: V2 annotation object
+
+        Returns:
+            (V1 annotation, V1 annotationData) tuple
+        """
+        annotation_id = v2_annotation.get('id', '')
+        classification_str = v2_annotation.get('classification', '')
+        attrs = v2_annotation.get('attrs', [])
+        data = v2_annotation.get('data', [0, 0, 0, 0])
+
+        # Build V1 coordinate
+        coordinate: dict[str, Any] = {
+            'x': data[0] if len(data) > 0 else 0,
+            'y': data[1] if len(data) > 1 else 0,
+            'width': data[2] if len(data) > 2 else 0,
+            'height': data[3] if len(data) > 3 else 0,
+        }
+
+        # Build V1 classification
+        classification: dict[str, Any] = {'class': classification_str}
+
+        # Restore properties from attrs
+        for attr in attrs:
+            name = attr.get('name', '')
+            value = attr.get('value')
+
+            if name in self._COORDINATE_ATTRS:
+                # Add rotation etc. to coordinate
+                coordinate[name] = value
+            elif not name.startswith(self._INTERNAL_ATTR_PREFIX):
+                # Add non-internal attrs to classification
+                classification[name] = value
+
+        # V1 annotation (meta info)
+        v1_annotation: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+            'classification': classification,
+        }
+
+        # V1 annotationData (coordinate info)
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'coordinate': coordinate,
+        }
+
+        return v1_annotation, v1_data

synapse_sdk/utils/converters/dm/tools/bounding_box_3d.py

@@ -0,0 +1,121 @@
+"""
+3D Bounding Box Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 9.6):
+V1 → V2:
+  - psr {position, scale, rotation} → data {position, scale, rotation}
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data {position, scale, rotation} → psr {position, scale, rotation}
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value} (excluding special attrs)
+"""
+
+from typing import Any
+
+
+class BoundingBox3DProcessor:
+    """3D Bounding Box Tool Processor
+
+    V1 psr: {position, scale, rotation} each {x, y, z}
+    V2 data: {position, scale, rotation} each {x, y, z}
+
+    PSR structure is identical, only key name changes (psr → data).
+    Used with pcd (point cloud) media type.
+    """
+
+    tool_name = '3d_bounding_box'
+
+    # V1 meta fields (not stored in attrs)
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+
+    # Special attrs not restored to V1 classification (_ prefix)
+    _INTERNAL_ATTR_PREFIX = '_'
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 3D bounding box to V2
+
+        Args:
+            v1_annotation: V1 annotations[] item
+            v1_data: V1 annotationsData[] item (same ID)
+
+        Returns:
+            V2 format 3D bounding box annotation
+        """
+        psr = v1_data.get('psr', {})
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # V2 data: copy psr structure as-is
+        data = {
+            'position': psr.get('position', {'x': 0, 'y': 0, 'z': 0}),
+            'scale': psr.get('scale', {'x': 0, 'y': 0, 'z': 0}),
+            'rotation': psr.get('rotation', {'x': 0, 'y': 0, 'z': 0}),
+        }
+
+        # Build V2 attrs
+        attrs: list[dict[str, Any]] = []
+
+        # Add other classification properties to attrs (excluding class)
+        for key, value in classification_obj.items():
+            if key != 'class':
+                attrs.append({'name': key, 'value': value})
+
+        # Build V2 annotation
+        return {
+            'id': v1_annotation.get('id', ''),
+            'classification': classification_obj.get('class', ''),
+            'attrs': attrs,
+            'data': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 3D bounding box to V1
+
+        Args:
+            v2_annotation: V2 annotation object
+
+        Returns:
+            (V1 annotation, V1 annotationData) tuple
+        """
+        annotation_id = v2_annotation.get('id', '')
+        classification_str = v2_annotation.get('classification', '')
+        attrs = v2_annotation.get('attrs', [])
+        data = v2_annotation.get('data', {})
+
+        # Build V1 psr: copy data structure as-is
+        psr: dict[str, Any] = {
+            'position': data.get('position', {'x': 0, 'y': 0, 'z': 0}),
+            'scale': data.get('scale', {'x': 0, 'y': 0, 'z': 0}),
+            'rotation': data.get('rotation', {'x': 0, 'y': 0, 'z': 0}),
+        }
+
+        # Build V1 classification
+        classification: dict[str, Any] = {'class': classification_str}
+
+        # Restore properties from attrs
+        for attr in attrs:
+            name = attr.get('name', '')
+            value = attr.get('value')
+
+            if not name.startswith(self._INTERNAL_ATTR_PREFIX):
+                # Add non-internal attrs to classification
+                classification[name] = value
+
+        # V1 annotation (meta info)
+        v1_annotation: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+            'classification': classification,
+        }
+
+        # V1 annotationData (coordinate info)
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'psr': psr,
+        }
+
+        return v1_annotation, v1_data

synapse_sdk/utils/converters/dm/tools/classification.py

@@ -0,0 +1,75 @@
+"""
+Classification Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 9.8):
+V1 → V2:
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+  - annotationsData contains only id
+
+V2 → V1:
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value}
+  - data is empty object {}
+"""
+
+from typing import Any
+
+
+class ClassificationProcessor:
+    """Classification Tool Processor
+
+    V1: All properties in annotations, only id in annotationsData
+    V2: data is empty object, all properties stored in attrs
+    """
+
+    tool_name = 'classification'
+
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+    _INTERNAL_ATTR_PREFIX = '_'
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 classification to V2"""
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # Build V2 attrs (all properties excluding class)
+        attrs: list[dict[str, Any]] = []
+        for key, value in classification_obj.items():
+            if key != 'class':
+                attrs.append({'name': key, 'value': value})
+
+        return {
+            'id': v1_annotation.get('id', ''),
+            'classification': classification_obj.get('class', ''),
+            'attrs': attrs,
+            'data': {},  # Empty object
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 classification to V1"""
+        annotation_id = v2_annotation.get('id', '')
+        classification_str = v2_annotation.get('classification', '')
+        attrs = v2_annotation.get('attrs', [])
+
+        # Build V1 classification
+        classification: dict[str, Any] = {'class': classification_str}
+        for attr in attrs:
+            name = attr.get('name', '')
+            value = attr.get('value')
+            if not name.startswith(self._INTERNAL_ATTR_PREFIX):
+                classification[name] = value
+
+        v1_annotation: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+            'classification': classification,
+        }
+
+        # annotationsData contains only id
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+        }
+
+        return v1_annotation, v1_data

synapse_sdk/utils/converters/dm/tools/keypoint.py

@@ -0,0 +1,117 @@
+"""
+Keypoint Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 9.2):
+V1 → V2:
+  - coordinate {x, y} → data [x, y]
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data [x, y] → coordinate {x, y}
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value} (excluding special attrs)
+"""
+
+from typing import Any
+
+
+class KeypointProcessor:
+    """Keypoint Tool Processor
+
+    V1 coordinate: {x, y}
+    V2 data: [x, y]
+
+    Simplest single point structure.
+    """
+
+    tool_name = 'keypoint'
+
+    # V1 meta fields (not stored in attrs)
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+
+    # Special attrs not restored to V1 classification (_ prefix)
+    _INTERNAL_ATTR_PREFIX = '_'
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 keypoint to V2
+
+        Args:
+            v1_annotation: V1 annotations[] item
+            v1_data: V1 annotationsData[] item (same ID)
+
+        Returns:
+            V2 format keypoint annotation
+        """
+        coordinate = v1_data.get('coordinate', {})
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # V2 data: [x, y] - extract x, y from coordinate object
+        data = [coordinate.get('x', 0), coordinate.get('y', 0)]
+
+        # Build V2 attrs
+        attrs: list[dict[str, Any]] = []
+
+        # Add other classification properties to attrs (excluding class)
+        for key, value in classification_obj.items():
+            if key != 'class':
+                attrs.append({'name': key, 'value': value})
+
+        # Build V2 annotation
+        return {
+            'id': v1_annotation.get('id', ''),
+            'classification': classification_obj.get('class', ''),
+            'attrs': attrs,
+            'data': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 keypoint to V1
+
+        Args:
+            v2_annotation: V2 annotation object
+
+        Returns:
+            (V1 annotation, V1 annotationData) tuple
+        """
+        annotation_id = v2_annotation.get('id', '')
+        classification_str = v2_annotation.get('classification', '')
+        attrs = v2_annotation.get('attrs', [])
+        data = v2_annotation.get('data', [])
+
+        # Build V1 coordinate: [x, y] → {x, y}
+        coordinate: dict[str, Any] = {}
+        if isinstance(data, list) and len(data) >= 2:
+            coordinate = {
+                'x': data[0],
+                'y': data[1],
+            }
+
+        # Build V1 classification
+        classification: dict[str, Any] = {'class': classification_str}
+
+        # Restore properties from attrs
+        for attr in attrs:
+            name = attr.get('name', '')
+            value = attr.get('value')
+
+            if not name.startswith(self._INTERNAL_ATTR_PREFIX):
+                # Add non-internal attrs to classification
+                classification[name] = value
+
+        # V1 annotation (meta info)
+        v1_annotation: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+            'classification': classification,
+        }
+
+        # V1 annotationData (coordinate info)
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'coordinate': coordinate,
+        }
+
+        return v1_annotation, v1_data

synapse_sdk/utils/converters/dm/tools/named_entity.py

@@ -0,0 +1,111 @@
+"""
+Named Entity Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 9.5):
+V1 → V2:
+  - ranges, content → data {ranges, content}
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data {ranges, content} → ranges, content
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value} (excluding special attrs)
+"""
+
+from typing import Any
+
+
+class NamedEntityProcessor:
+    """Named Entity Tool Processor
+
+    V1 annotationData: {ranges: [...], content: str}
+    V2 data: {ranges: [...], content: str}
+
+    Used with text media type.
+    """
+
+    tool_name = 'named_entity'
+
+    # V1 meta fields (not stored in attrs)
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+
+    # Special attrs not restored to V1 classification (_ prefix)
+    _INTERNAL_ATTR_PREFIX = '_'
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 named entity to V2
+
+        Args:
+            v1_annotation: V1 annotations[] item
+            v1_data: V1 annotationsData[] item (same ID)
+
+        Returns:
+            V2 format named entity annotation
+        """
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # V2 data: {ranges, content}
+        data = {
+            'ranges': v1_data.get('ranges', []),
+            'content': v1_data.get('content', ''),
+        }
+
+        # Build V2 attrs
+        attrs: list[dict[str, Any]] = []
+
+        # Add other classification properties to attrs (excluding class)
+        for key, value in classification_obj.items():
+            if key != 'class':
+                attrs.append({'name': key, 'value': value})
+
+        # Build V2 annotation
+        return {
+            'id': v1_annotation.get('id', ''),
+            'classification': classification_obj.get('class', ''),
+            'attrs': attrs,
+            'data': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 named entity to V1
+
+        Args:
+            v2_annotation: V2 annotation object
+
+        Returns:
+            (V1 annotation, V1 annotationData) tuple
+        """
+        annotation_id = v2_annotation.get('id', '')
+        classification_str = v2_annotation.get('classification', '')
+        attrs = v2_annotation.get('attrs', [])
+        data = v2_annotation.get('data', {})
+
+        # Build V1 classification
+        classification: dict[str, Any] = {'class': classification_str}
+
+        # Restore properties from attrs
+        for attr in attrs:
+            name = attr.get('name', '')
+            value = attr.get('value')
+
+            if not name.startswith(self._INTERNAL_ATTR_PREFIX):
+                classification[name] = value
+
+        # V1 annotation (meta info)
+        v1_annotation: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+            'classification': classification,
+        }
+
+        # V1 annotationData (ranges, content)
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'ranges': data.get('ranges', []),
+            'content': data.get('content', ''),
+        }
+
+        return v1_annotation, v1_data

synapse_sdk/utils/converters/dm/tools/polygon.py

@@ -0,0 +1,122 @@
+"""
+Polygon Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 4.2):
+V1 → V2:
+  - coordinate [{x, y, id}, ...] → data [[x, y], ...]
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data [[x, y], ...] → coordinate [{x, y, id}, ...]
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value} (excluding special attrs)
+"""
+
+from typing import Any
+
+from ..utils import generate_random_id
+
+
+class PolygonProcessor:
+    """Polygon Tool Processor
+
+    V1 coordinate: [{x, y, id}, ...]
+    V2 data: [[x, y], ...]
+    """
+
+    tool_name = 'polygon'
+
+    # V1 meta fields (not stored in attrs)
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+
+    # Special attrs not restored to V1 classification (_ prefix)
+    _INTERNAL_ATTR_PREFIX = '_'
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 polygon to V2
+
+        Args:
+            v1_annotation: V1 annotations[] item
+            v1_data: V1 annotationsData[] item (same ID)
+
+        Returns:
+            V2 format polygon annotation
+        """
+        coordinate = v1_data.get('coordinate', [])
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # V2 data: [[x, y], ...] - extract only x, y from coordinate array
+        data = []
+        for point in coordinate:
+            if isinstance(point, dict):
+                data.append([point.get('x', 0), point.get('y', 0)])
+
+        # Build V2 attrs
+        attrs: list[dict[str, Any]] = []
+
+        # Add other classification properties to attrs (excluding class)
+        for key, value in classification_obj.items():
+            if key != 'class':
+                attrs.append({'name': key, 'value': value})
+
+        # Build V2 annotation
+        return {
+            'id': v1_annotation.get('id', ''),
+            'classification': classification_obj.get('class', ''),
+            'attrs': attrs,
+            'data': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 polygon to V1
+
+        Args:
+            v2_annotation: V2 annotation object
+
+        Returns:
+            (V1 annotation, V1 annotationData) tuple
+        """
+        annotation_id = v2_annotation.get('id', '')
+        classification_str = v2_annotation.get('classification', '')
+        attrs = v2_annotation.get('attrs', [])
+        data = v2_annotation.get('data', [])
+
+        # Build V1 coordinate: [[x, y], ...] → [{x, y, id}, ...]
+        coordinate: list[dict[str, Any]] = []
+        for point in data:
+            if isinstance(point, list) and len(point) >= 2:
+                coordinate.append({
+                    'x': point[0],
+                    'y': point[1],
+                    'id': generate_random_id(),
+                })
+
+        # Build V1 classification
+        classification: dict[str, Any] = {'class': classification_str}
+
+        # Restore properties from attrs
+        for attr in attrs:
+            name = attr.get('name', '')
+            value = attr.get('value')
+
+            if not name.startswith(self._INTERNAL_ATTR_PREFIX):
+                # Add non-internal attrs to classification
+                classification[name] = value
+
+        # V1 annotation (meta info)
+        v1_annotation: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+            'classification': classification,
+        }
+
+        # V1 annotationData (coordinate info)
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'coordinate': coordinate,
+        }
+
+        return v1_annotation, v1_data