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

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

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

@@ -0,0 +1,124 @@
+"""
+Polyline 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 PolylineProcessor:
+    """Polyline Tool Processor
+
+    V1 coordinate: [{x, y, id}, ...]
+    V2 data: [[x, y], ...]
+
+    Same data structure as polygon, only tool_name differs.
+    """
+
+    tool_name = 'polyline'
+
+    # 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 polyline to V2
+
+        Args:
+            v1_annotation: V1 annotations[] item
+            v1_data: V1 annotationsData[] item (same ID)
+
+        Returns:
+            V2 format polyline 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 polyline 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

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

@@ -0,0 +1,94 @@
+"""
+Prompt Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 9.10):
+V1 → V2:
+  - input → data.input
+  - Other fields from annotationsData → preserved in data
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data.input → input
+  - Other fields from data → preserved in annotationsData
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value}
+"""
+
+from typing import Any
+
+
+class PromptProcessor:
+    """Prompt Tool Processor
+
+    V1 annotationsData: {id, tool, input: [{type, value, changeHistory}]}
+    V2 data: {input: [...], model?, displayName?, generatedBy?, timestamp?}
+
+    Prompt annotation data conversion.
+    """
+
+    tool_name = 'prompt'
+
+    _META_FIELDS = {'isLocked', 'isVisible', 'isValid', 'isDrawCompleted', 'label', 'id', 'tool'}
+    _INTERNAL_ATTR_PREFIX = '_'
+    # Fields to copy from annotationsData to V2 data
+    _DATA_FIELDS = {'input', 'model', 'displayName', 'generatedBy', 'timestamp'}
+
+    def to_v2(self, v1_annotation: dict[str, Any], v1_data: dict[str, Any]) -> dict[str, Any]:
+        """Convert V1 prompt to V2"""
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # Build V2 data (input and other fields)
+        data: dict[str, Any] = {}
+        for key in self._DATA_FIELDS:
+            if key in v1_data:
+                data[key] = v1_data[key]
+
+        # Build V2 attrs (all classification 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': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 prompt to V1"""
+        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}
+        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,
+        }
+
+        # Build V1 annotationsData
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'tool': self.tool_name,
+        }
+
+        # Copy fields from data
+        for key in self._DATA_FIELDS:
+            if key in data:
+                v1_data[key] = data[key]
+
+        return v1_annotation, v1_data

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

@@ -0,0 +1,86 @@
+"""
+Relation Tool Processor
+
+Created: 2025-12-12
+
+Conversion Rules (see data-model.md 9.9):
+V1 → V2:
+  - annotationId, targetAnnotationId → data [from_id, to_id]
+  - classification.class → classification
+  - classification.{other} → attrs[{name, value}]
+
+V2 → V1:
+  - data [from_id, to_id] → annotationId, targetAnnotationId
+  - classification → classification.class
+  - attrs[{name, value}] → classification.{name: value}
+"""
+
+from typing import Any
+
+
+class RelationProcessor:
+    """Relation Tool Processor
+
+    V1 annotationData: {annotationId, targetAnnotationId}
+    V2 data: [from_id, to_id]
+
+    Represents relationship between two annotations.
+    """
+
+    tool_name = 'relation'
+
+    _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 relation to V2"""
+        classification_obj = v1_annotation.get('classification') or {}
+
+        # V2 data: [from_id, to_id]
+        data = [
+            v1_data.get('annotationId', ''),
+            v1_data.get('targetAnnotationId', ''),
+        ]
+
+        # Build V2 attrs
+        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': data,
+        }
+
+    def to_v1(self, v2_annotation: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Convert V2 relation to V1"""
+        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}
+        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,
+        }
+
+        # V1 annotationData
+        v1_data: dict[str, Any] = {
+            'id': annotation_id,
+            'annotationId': data[0] if len(data) > 0 else '',
+            'targetAnnotationId': data[1] if len(data) > 1 else '',
+        }
+
+        return v1_annotation, v1_data