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

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

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

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk/utils/converters/__init__.py

@@ -2,16 +2,25 @@ import json
 import os
 import shutil
 import uuid
+from typing import IO
 
 
 class BaseConverter:
     """Base class for shared logic between converters."""
 
-    def __init__(self, root_dir: str, is_categorized_dataset: bool = False) -> None:
+    def __init__(
+        self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False
+    ) -> None:
         self.root_dir: str = root_dir
         self.is_categorized_dataset: bool = is_categorized_dataset
+        self.is_single_conversion: bool = is_single_conversion
         self.converted_data = None
 
+        # Set directories if single_conversion is False.
+        if not is_single_conversion:
+            if not root_dir:
+                raise ValueError('root_dir must be specified for conversion')
+
     @staticmethod
     def ensure_dir(path: str) -> None:
         """Ensure that the directory exists, creating it if necessary."""
@@ -55,6 +64,24 @@ class BaseConverter:
 
         return splits
 
+    def convert_single_file(self, data, original_file: IO, **kwargs):
+        """Convert a single data object and corresponding original file.
+
+        This method should be implemented by subclasses for single file conversion.
+        Only available when is_single_conversion=True.
+
+        Args:
+            data: The data object to convert (dict for JSON data, etc.)
+            original_file_path: File object for the corresponding original file
+            **kwargs: Additional parameters specific to each converter
+
+        Returns:
+            Converted data in the target format
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+        raise NotImplementedError('Subclasses must implement convert_single_file method')
+
     def _set_directories(self, split=None):
         """Set `self.json_dir` and `self.original_file_dir` based on the dataset split."""
         if split:
@@ -106,8 +133,10 @@ class FromDMConverter(BaseConverter):
         converter.save_to_folder('/my/target/output')  # Writes files/folders to output location
     """
 
-    def __init__(self, root_dir: str, is_categorized_dataset: bool = False) -> None:
-        super().__init__(root_dir, is_categorized_dataset)
+    def __init__(
+        self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False
+    ) -> None:
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
         self.version: str = '1.0'
 
     def convert(self):

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk/utils/converters/coco/from_dm.py

@@ -3,7 +3,7 @@ import json
 import os
 import shutil
 from glob import glob
-from typing import Any, Dict
+from typing import Any, Dict, IO
 
 from PIL import Image
 from tqdm import tqdm
@@ -22,14 +22,23 @@ class FromDMToCOCOConverter(FromDMConverter):
         # 'audio': ['.wav', '.mp3', ...]
     }
 
-    def __init__(self, root_dir, info_dict=None, licenses_list=None, data_type='img', is_categorized_dataset=False):
+    def __init__(
+        self,
+        root_dir=None,
+        info_dict=None,
+        licenses_list=None,
+        data_type='img',
+        is_categorized_dataset=False,
+        is_single_conversion=False,
+    ):
         """Args:
         root_dir (str): Root directory containing data.
         info_dict, licenses_list: COCO metadata.
         data_type (str): Which data type to use (default: 'img').
         is_categorized_dataset (bool): Whether to handle train, test, valid splits.
+        is_single_conversion (bool): Whether to use single file conversion mode.
         """
-        super().__init__(root_dir, is_categorized_dataset)
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
         self.data_type = data_type
         self.info_dict = info_dict or self._default_info()
         self.licenses_list = licenses_list or self._default_licenses()
@@ -267,3 +276,47 @@ class FromDMToCOCOConverter(FromDMConverter):
                 shutil.copy(src_path, dst_path)
             else:
                 print(f'[WARNING] Image not found: {src_path}')
+
+    def convert_single_file(self, data: Dict[str, Any], original_file: IO) -> Dict[str, Any]:
+        """Convert a single DM data dict and corresponding image file object to COCO format.
+
+        Args:
+            data: DM format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing COCO format data for the single file
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        self.reset_state()
+        self.coco_dict = {
+            'info': self.info_dict,
+            'licenses': self.licenses_list,
+            'images': [],
+            'annotations': [],
+            'categories': [],
+        }
+
+        # Process the image file
+        with Image.open(original_file) as im:
+            width, height = im.size
+
+        image_info = {
+            'id': self.img_id,
+            'file_name': getattr(original_file, 'name', 'image.jpg'),
+            'width': width,
+            'height': height,
+            'license': self.license_id,
+        }
+        self.coco_dict['images'].append(image_info)
+
+        # Process annotations from the first (and only) image in data
+        if 'images' in data and len(data['images']) > 0:
+            anns = data['images'][0]
+            self._process_polylines(anns)
+            self._process_bboxes(anns)
+            self._process_keypoints(anns)
+
+        return self.coco_dict

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk/utils/converters/coco/to_dm.py

@@ -1,5 +1,6 @@
 import json
 import os
+from typing import IO, Any, Dict
 
 from synapse_sdk.utils.converters import ToDMConverter
 
@@ -7,6 +8,9 @@ from synapse_sdk.utils.converters import ToDMConverter
 class COCOToDMConverter(ToDMConverter):
     """Convert COCO format annotations to DM (Data Manager) format."""
 
+    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
+
     def convert(self):
         if self.is_categorized_dataset:
             splits = self._validate_splits(['train', 'valid'], ['test'])
@@ -111,3 +115,101 @@ class COCOToDMConverter(ToDMConverter):
             dm_json = {'images': [dm_img]}
             result[img_filename] = (dm_json, img_path)
         return result
+
+    def convert_single_file(self, data: Dict[str, Any], original_file: IO) -> Dict[str, Any]:
+        """Convert a single COCO annotation data and corresponding image to DM format.
+
+        Args:
+            data: COCO format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing DM format data for the single file
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        images = data.get('images', [])
+        annotations = data.get('annotations', [])
+        categories = data.get('categories', [])
+
+        if not images:
+            raise ValueError('No images found in COCO data')
+
+        # Get file name from original_file
+        img_path = getattr(original_file, 'name', None)
+        if not img_path:
+            raise ValueError('original_file must have a "name" attribute representing its path or filename.')
+        img_basename = os.path.basename(img_path)
+
+        # Find the matching image info in COCO 'images' section by comparing file name
+        # COCO image dicts might use 'file_name', 'filename', or similar
+        matched_img = None
+        for img in images:
+            for key in ['file_name', 'filename', 'name']:
+                if key in img and os.path.basename(img[key]) == img_basename:
+                    matched_img = img
+                    break
+            if matched_img:
+                break
+
+        if not matched_img:
+            raise ValueError(f'No matching image found in COCO data for file: {img_basename}')
+
+        img_id = matched_img['id']
+        print('img_id : ', img_id)
+        cat_map = {cat['id']: cat for cat in categories}
+        anns = [ann for ann in annotations if ann['image_id'] == img_id]
+
+        dm_img = {
+            'bounding_box': [],
+            'keypoint': [],
+            'relation': [],
+            'group': [],
+        }
+
+        bbox_ids = []
+        for ann in anns:
+            cat = cat_map.get(ann['category_id'], {})
+            if 'bbox' in ann and ann['bbox']:
+                bbox_id = self._generate_unique_id()
+                bbox_ids.append(bbox_id)
+                dm_img['bounding_box'].append({
+                    'id': bbox_id,
+                    'classification': cat.get('name', str(ann['category_id'])),
+                    'attrs': ann.get('attrs', []),
+                    'data': list(ann['bbox']),
+                })
+
+        for ann in anns:
+            cat = cat_map.get(ann['category_id'], {})
+            attrs = ann.get('attrs', [])
+            if 'keypoints' in ann and ann['keypoints']:
+                kp_names = cat.get('keypoints', [])
+                kps = ann['keypoints']
+                keypoint_ids = []
+                for idx in range(min(len(kps) // 3, len(kp_names))):
+                    x, y, _ = kps[idx * 3 : idx * 3 + 3]
+                    kp_id = self._generate_unique_id()
+                    keypoint_ids.append(kp_id)
+                    dm_img['keypoint'].append({
+                        'id': kp_id,
+                        'classification': kp_names[idx] if idx < len(kp_names) else f'keypoint_{idx}',
+                        'attrs': attrs,
+                        'data': [x, y],
+                    })
+                group_ids = bbox_ids + keypoint_ids
+                if group_ids:
+                    dm_img['group'].append({
+                        'id': self._generate_unique_id(),
+                        'classification': cat.get('name', str(ann['category_id'])),
+                        'attrs': attrs,
+                        'data': group_ids,
+                    })
+
+        dm_json = {'images': [dm_img]}
+        return {
+            'dm_json': dm_json,
+            'image_path': img_path,
+            'image_name': img_basename,
+        }

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk/utils/converters/pascal/from_dm.py

@@ -3,7 +3,7 @@ import os
 import shutil
 import xml.etree.ElementTree as ET
 from glob import glob
-from typing import Any, List, Optional
+from typing import Any, Dict, IO, List, Optional
 
 from PIL import Image
 
@@ -15,8 +15,8 @@ class FromDMToPascalConverter(FromDMConverter):
 
     IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
 
-    def __init__(self, root_dir: str, is_categorized_dataset: bool = False):
-        super().__init__(root_dir, is_categorized_dataset)
+    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
         self.class_names = set()
 
     def find_image_for_base(self, img_dir: str, base: str) -> Optional[str]:
@@ -175,3 +175,48 @@ class FromDMToPascalConverter(FromDMConverter):
             for c in sorted(self.class_names):
                 f.write(f'{c}\n')
         print(f'Pascal VOC data exported to {outdir}')
+
+    def convert_single_file(self, data: Dict[str, Any], original_file: IO) -> Dict[str, Any]:
+        """Convert a single DM data dict and corresponding image file object to Pascal VOC format.
+
+        Args:
+            data: DM format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing Pascal VOC format data for the single file
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        # Extract image info from file object
+        with Image.open(original_file) as img:
+            width, height = img.size
+            depth = len(img.getbands())
+
+        # Get filename from original_file
+        img_filename = getattr(original_file, 'name', 'image.jpg')
+        if img_filename:
+            img_filename = os.path.basename(img_filename)
+
+        # Process annotations from the first (and only) image in data
+        if 'images' in data and len(data['images']) > 0:
+            img_ann = data['images'][0]
+            objects = self.parse_dm_annotations(img_ann)
+        else:
+            objects = []
+
+        # Build Pascal VOC XML
+        xml_tree = self.build_pascal_xml(img_filename, (width, height, depth), objects)
+        xml_filename = os.path.splitext(img_filename)[0] + '.xml'
+
+        # Convert XML tree to string for easy viewing
+        xml_string = ET.tostring(xml_tree.getroot(), encoding='unicode', xml_declaration=True)
+
+        return {
+            'xml_tree': xml_tree,
+            'xml_content': xml_string,
+            'xml_filename': xml_filename,
+            'image_filename': img_filename,
+            'class_names': sorted(list(self.class_names)),
+        }

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/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, List, Optional, Tuple
+from typing import Any, Dict, IO, List, Optional, Tuple
 
 from PIL import Image
 
@@ -12,6 +12,9 @@ class PascalToDMConverter(ToDMConverter):
 
     IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
 
+    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
+
     def convert(self):
         """Convert the Pascal VOC dataset to DM format."""
         if self.is_categorized_dataset:
@@ -133,3 +136,79 @@ class PascalToDMConverter(ToDMConverter):
                 print(f'[WARNING] Error processing {xml_filename}: {e}, skipping.')
                 continue
         return result
+
+    def convert_single_file(self, data: str, original_file: IO) -> Dict[str, Any]:
+        """Convert a single Pascal VOC XML data and corresponding image to DM format.
+
+        Args:
+            data: Pascal VOC XML content as string
+            original_file: File object for the corresponding original image
+
+        Returns:
+            Dictionary containing DM format data for the single file
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        # Get filename from original_file
+        img_path = getattr(original_file, 'name', None)
+        if not img_path:
+            raise ValueError('original_file must have a "name" attribute representing its path or filename.')
+
+        img_filename = os.path.basename(img_path)
+
+        # Parse XML data from string
+        try:
+            root = ET.fromstring(data)
+        except ET.ParseError as e:
+            raise ValueError(f'Failed to parse Pascal VOC XML data: {e}')
+
+        # Extract objects from XML
+        objects = []
+        for obj in root.findall('object'):
+            name_elem = obj.find('name')
+            bndbox_elem = obj.find('bndbox')
+            if name_elem is None or bndbox_elem is None:
+                continue
+
+            class_name = name_elem.text
+            xmin_elem = bndbox_elem.find('xmin')
+            ymin_elem = bndbox_elem.find('ymin')
+            xmax_elem = bndbox_elem.find('xmax')
+            ymax_elem = bndbox_elem.find('ymax')
+
+            if any(elem is None for elem in [xmin_elem, ymin_elem, xmax_elem, ymax_elem]):
+                continue
+
+            xmin = int(float(xmin_elem.text))
+            ymin = int(float(ymin_elem.text))
+            xmax = int(float(xmax_elem.text))
+            ymax = int(float(ymax_elem.text))
+            width = xmax - xmin
+            height = ymax - ymin
+
+            objects.append({'classification': class_name, 'data': [xmin, ymin, width, height]})
+
+        # Prepare DM annotation structure
+        dm_img = {
+            'bounding_box': [],
+            'polygon': [],
+            'keypoint': [],
+            'relation': [],
+            'group': [],
+        }
+
+        for obj in objects:
+            dm_img['bounding_box'].append({
+                'id': self._generate_unique_id(),
+                'classification': obj['classification'],
+                'attrs': [],
+                'data': obj['data'],
+            })
+
+        dm_json = {'images': [dm_img]}
+        return {
+            'dm_json': dm_json,
+            'image_path': img_path,
+            'image_name': img_filename,
+        }

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk/utils/converters/yolo/from_dm.py

@@ -2,7 +2,7 @@ import json
 import os
 import shutil
 from glob import glob
-from typing import Any, Dict, List, Optional, Union
+from typing import IO, Any, Dict, List, Optional, Union
 
 from PIL import Image
 
@@ -14,8 +14,8 @@ class FromDMToYOLOConverter(FromDMConverter):
 
     IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
 
-    def __init__(self, root_dir: str, is_categorized_dataset: bool = False):
-        super().__init__(root_dir, is_categorized_dataset)
+    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
         self.class_names: List[str] = []
         self.class_map: Dict[str, int] = {}
         self.dataset_yaml_content: str = ''
@@ -300,3 +300,85 @@ class FromDMToYOLOConverter(FromDMConverter):
             for c in self.class_names:
                 f.write(f'{c}\n')
         print(f'YOLO data exported to {output_dir}')
+
+    def convert_single_file(
+        self, data: Dict[str, Any], original_file: IO, class_names: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Convert a single DM data dict and corresponding image file object to YOLO format.
+
+        Args:
+            data: DM format data dictionary (JSON content)
+            original_file: File object for the corresponding original image
+            class_names: Optional list of class names. If not provided, classes will be extracted from data.
+
+        Returns:
+            Dictionary containing YOLO format data for the single file
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        if class_names is None:
+            classes = set()
+            for img_ann in data['images']:
+                for k in ['bounding_box', 'polygon', 'keypoint']:
+                    if k in img_ann:
+                        for ann in img_ann[k]:
+                            classes.add(ann['classification'])
+            class_names = sorted(list(classes))
+
+        class_map = {name: idx for idx, name in enumerate(class_names)}
+        # You need to update get_image_size to accept a file object
+        width, height = self.get_image_size(original_file)
+
+        img_ann = data['images'][0]
+        label_lines = []
+
+        # bbox
+        if 'bounding_box' in img_ann:
+            for box in img_ann['bounding_box']:
+                if box['classification'] not in class_map:
+                    continue
+                cidx = class_map[box['classification']]
+                x, y, w, h = box['data']
+                cx = x + w / 2
+                cy = y + h / 2
+                cx /= width
+                cy /= height
+                w /= width
+                h /= height
+                label_lines.append(f'{cidx} {cx:.6f} {cy:.6f} {w:.6f} {h:.6f}')
+
+        # polygon
+        if 'polygon' in img_ann:
+            for poly in img_ann['polygon']:
+                if poly['classification'] not in class_map:
+                    continue
+                cidx = class_map[poly['classification']]
+                poly_str = self.polygon_to_yolo_string(poly['data'], width, height)
+                if poly_str:
+                    label_lines.append(f'{cidx} {poly_str}')
+
+        # keypoint
+        if 'keypoint' in img_ann:
+            for kp in img_ann['keypoint']:
+                if kp['classification'] not in class_map:
+                    continue
+                cidx = class_map[kp['classification']]
+                if 'bounding_box' in kp:
+                    x, y, w, h = kp['bounding_box']
+                    cx = x + w / 2
+                    cy = y + h / 2
+                    cx /= width
+                    cy /= height
+                    w /= width
+                    h /= height
+                else:
+                    cx, cy, w, h = 0.5, 0.5, 1.0, 1.0
+                kp_str = self.keypoints_to_yolo_string(kp['data'], width, height)
+                label_lines.append(f'{cidx} {cx:.6f} {cy:.6f} {w:.6f} {h:.6f} {kp_str}')
+
+        return {
+            'label_lines': label_lines,
+            'class_names': class_names,
+            'class_map': class_map,
+        }

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk/utils/converters/yolo/to_dm.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Dict, List, Tuple
+from typing import IO, Any, Dict, List, Tuple
 
 import yaml
 from PIL import Image
@@ -12,6 +12,9 @@ class YOLOToDMConverter(ToDMConverter):
 
     IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
 
+    def __init__(self, root_dir: str = None, is_categorized_dataset: bool = False, is_single_conversion: bool = False):
+        super().__init__(root_dir, is_categorized_dataset, is_single_conversion)
+
     def convert(self):
         """Convert YOLO dataset to DM format."""
         if self.is_categorized_dataset:
@@ -183,3 +186,73 @@ class YOLOToDMConverter(ToDMConverter):
             dm_json = {'images': [dm_img]}
             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]:
+        """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
+        """
+        if not self.is_single_conversion:
+            raise RuntimeError('convert_single_file is only available when is_single_conversion=True')
+
+        img_path = getattr(original_file, 'name', None)
+        if not img_path:
+            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)
+        else:
+            raise AttributeError('Converter missing _get_image_size method for file objects.')
+
+        # data is already a list of label lines
+        label_lines = [line.strip() for line in data if line.strip()]
+
+        # Prepare DM annotation structure
+        dm_img = {
+            'bounding_box': [],
+            'polygon': [],
+            'keypoint': [],
+            'relation': [],
+            'group': [],
+        }
+
+        for line in label_lines:
+            ann = self._parse_yolo_line(line, class_names, img_size)
+            if ann is None:
+                continue
+
+            if ann['type'] == 'bounding_box':
+                dm_img['bounding_box'].append({
+                    'id': self._generate_unique_id(),
+                    'classification': ann['classification'],
+                    'attrs': [],
+                    'data': ann['data'],
+                })
+            elif ann['type'] == 'polygon':
+                dm_img['polygon'].append({
+                    'id': self._generate_unique_id(),
+                    'classification': ann['classification'],
+                    'attrs': [],
+                    'data': ann['data'],
+                })
+            elif ann['type'] == 'keypoint':
+                dm_img['keypoint'].append({
+                    'id': self._generate_unique_id(),
+                    'classification': ann['classification'],
+                    'attrs': [],
+                    'data': ann['data'],
+                    'bounding_box': ann['bounding_box'],
+                })
+
+        dm_json = {'images': [dm_img]}
+        return {
+            'dm_json': dm_json,
+            'image_path': img_path,
+            'image_name': os.path.basename(img_path),
+        }

{synapse_sdk-1.0.0a78 → synapse_sdk-1.0.0a80}/synapse_sdk.egg-info/PKG-INFO

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