synapse-sdk 1.0.0a70__py3-none-any.whl → 1.0.0a72__py3-none-any.whl

synapse_sdk/loggers.py

@@ -110,7 +110,7 @@ class BaseLogger:
         if 'categories' not in self.metrics_record:
             self.metrics_record['categories'] = {}
 
-        self.metrics_record['categories'][category] = value
+        self.metrics_record['categories'].setdefault(category, {}).update(value)
 
     def log(self, action, data, file=None):
         raise NotImplementedError

synapse_sdk/plugins/categories/export/actions/export.py

@@ -280,7 +280,18 @@ class ExportAction(Action):
             'proportion': 100,
         }
     }
-    metrics_categories = {'data_file', 'original_file'}
+    metrics_categories = {
+        'data_file': {
+            'stand_by': 0,
+            'failed': 0,
+            'success': 0,
+        },
+        'original_file': {
+            'stand_by': 0,
+            'failed': 0,
+            'success': 0,
+        },
+    }
 
     def get_filtered_results(self, filters, handler):
         """Get filtered target results."""

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

@@ -67,9 +67,11 @@ class ToTaskParams(BaseModel):
         name (str): The name of the action.
         description (str | None): The description of the action.
         project (int): The project ID.
+        agent (int): The agent ID.
         task_filters (dict): The filters of tasks.
         method (AnnotationMethod): The method of annotation.
         target_specification_name (str | None): The name of the target specification.
+        model (int): The model ID.
         pre_processor (int | None): The pre processor ID.
         pre_processor_params (dict): The params of the pre processor.
     """
@@ -77,9 +79,11 @@ class ToTaskParams(BaseModel):
     name: Annotated[str, AfterValidator(non_blank)]
     description: Optional[str] = None
     project: int
+    agent: int
     task_filters: Dict[str, Any]
     method: Optional[AnnotationMethod] = None
     target_specification_name: Optional[str] = None
+    model: Optional[int] = None
     pre_processor: Optional[int] = None
     pre_processor_params: Dict[str, Any]
 
@@ -142,7 +146,13 @@ class ToTaskAction(Action):
             'proportion': 100,
         },
     }
-    metrics_categories = {'annotate_task_data'}
+    metrics_categories = {
+        'annotate_task_data': {
+            'stand_by': 0,
+            'failed': 0,
+            'success': 0,
+        }
+    }
 
     def start(self):
         """Start to_task action.
@@ -256,7 +266,9 @@ class ToTaskAction(Action):
         # Process each task
         for task_id in task_ids:
             try:
-                result = self._process_single_task(client, task_id, task_params, target_specification_name)
+                result = self._process_single_task(
+                    client, task_id, task_params, target_specification_name, AnnotationMethod.FILE
+                )
                 if result['success']:
                     success_count += 1
                 else:
@@ -279,7 +291,12 @@ class ToTaskAction(Action):
         self.run.log_message(f'Annotation completed. Success: {success_count}, Failed: {failed_count}')
 
     def _process_single_task(
-        self, client: BackendClient, task_id: int, task_params: Dict[str, Any], target_specification_name: str
+        self,
+        client: BackendClient,
+        task_id: int,
+        task_params: Dict[str, Any],
+        target_specification_name: Optional[str],
+        method: AnnotationMethod,
     ) -> Dict[str, Any]:
         """Process a single task for annotation.
 
@@ -287,7 +304,8 @@ class ToTaskAction(Action):
             client (BackendClient): The backend client instance.
             task_id (int): The task ID to process.
             task_params (Dict[str, Any]): Parameters for getting task data.
-            target_specification_name (str): The name of the target specification.
+            target_specification_name (Optional[str]): The name of the target specification.
+            method (AnnotationMethod): The annotation method to use.
 
         Returns:
             Dict[str, Any]: Result dictionary with 'success' boolean and optional 'error' message.
@@ -308,6 +326,41 @@ class ToTaskAction(Action):
 
         task: Dict[str, Any] = task_response
 
+        if method == AnnotationMethod.FILE:
+            if not target_specification_name:
+                error_msg = 'Target specification name is required for file annotation method'
+                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}
+            return self._process_single_task_with_file(client, task_id, task, target_specification_name)
+        elif method == AnnotationMethod.INFERENCE:
+            return self._process_single_task_with_inference(client, task_id, task)
+        else:
+            error_msg = f'Unsupported annotation method: {method}'
+            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}
+
+    def _process_single_task_with_file(
+        self, client: BackendClient, task_id: int, task: Dict[str, Any], target_specification_name: str
+    ) -> Dict[str, Any]:
+        """Process a single task for file-based annotation.
+
+        Args:
+            client (BackendClient): The backend client instance.
+            task_id (int): The task ID to process.
+            task (Dict[str, Any]): The task data.
+            target_specification_name (str): The name of the target specification.
+
+        Returns:
+            Dict[str, Any]: Result dictionary with 'success' boolean and optional 'error' message.
+        """
+        if not self.run:
+            raise ValueError('Run instance not properly initialized')
+
+        # Type assertion to help the linter
+        assert isinstance(self.run, ToTaskRun)
+
         # Extract data file information
         data_unit = task.get('data_unit', {})
         files = data_unit.get('files', {})
@@ -332,8 +385,12 @@ class ToTaskAction(Action):
             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': 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)
@@ -350,6 +407,84 @@ class ToTaskAction(Action):
             self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
             return {'success': False, 'error': error_msg}
 
+    def _process_single_task_with_inference(
+        self, client: BackendClient, task_id: int, task: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Process a single task for inference-based annotation.
+
+        Args:
+            client (BackendClient): The backend client instance.
+            task_id (int): The task ID to process.
+            task (Dict[str, Any]): The task data.
+
+        Returns:
+            Dict[str, Any]: Result dictionary with 'success' boolean and optional 'error' message.
+        """
+        if not self.run or not self.params:
+            raise ValueError('Run instance or parameters not properly initialized')
+
+        # Type assertion to help the linter
+        assert isinstance(self.run, ToTaskRun)
+
+        try:
+            # Get pre-processor information
+            pre_processor_id = self.params.get('pre_processor')
+
+            if not pre_processor_id:
+                error_msg = 'Pre-processor ID is required for inference annotation method'
+                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}
+
+            # Call inference pre processor if specified.
+            pre_processor = client.get_plugin_release(pre_processor_id)
+            pre_processor_code = pre_processor['config']['code']
+            pre_processor_version = pre_processor['version']
+
+            # Extract task data for inference
+            data_unit = task.get('data_unit', {})
+            files = data_unit.get('files', {})
+
+            # Find primary image URL from files
+            primary_file_url = ''
+            for file_info in files.values():
+                if file_info.get('is_primary') and file_info.get('url'):
+                    primary_file_url = file_info['url']
+                    break
+
+            pre_processor_params = self.params.get('pre_processor_params', {})
+            pre_processor_params['image_path'] = primary_file_url
+            inference_payload = {
+                'agent': 1,
+                'action': 'inference',
+                'version': pre_processor_version,
+                'params': {
+                    'model': self.params.get('model'),
+                    'method': 'post',
+                    'json': pre_processor_params,
+                },
+            }
+            inference_data = client.run_plugin(pre_processor_code, inference_payload)
+
+            # Convert data to task object
+            annotation_to_task = self.entrypoint(self.run)
+            converted_result = annotation_to_task.convert_data_from_inference(inference_data)
+
+            # Submit inference annotation data
+            client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_result})
+
+            # Log success
+            self.run.log_annotate_task_data(
+                {'task_id': task_id, 'pre_processor_id': pre_processor_id}, AnnotateTaskDataStatus.SUCCESS
+            )
+            return {'success': True}
+
+        except Exception as e:
+            error_msg = f'Failed to process inference for task {task_id}: {str(e)}'
+            self.run.log_message(error_msg)
+            self.run.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+            return {'success': False, 'error': error_msg}
+
     def _update_metrics(self, total_tasks: int, success_count: int, failed_count: int):
         """Update metrics for task annotation progress.
 
@@ -375,8 +510,53 @@ class ToTaskAction(Action):
         Args:
             task_ids (List[int]): List of task IDs to annotate data to.
         """
-        if not self.run:
-            raise ValueError('Run instance not properly initialized')
+        if not self.run or not self.params:
+            raise ValueError('Run instance or parameters not properly initialized')
 
-        self.run.log_message('Pre annotation with inference is not supported.')
-        self.run.end_log()
+        if not self.params.get('model'):
+            raise ValueError('Model is required for inference annotation method')
+
+        # Type assertion to help the linter
+        assert isinstance(self.run, ToTaskRun)
+        assert isinstance(self.run.client, BackendClient)
+
+        client: BackendClient = self.run.client
+        task_params = {
+            'fields': 'id,data,data_unit',
+            'expand': 'data_unit',
+        }
+
+        total_tasks = len(task_ids)
+        success_count = 0
+        failed_count = 0
+        current_progress = 0
+
+        # Initialize metrics and progress
+        self._update_metrics(total_tasks, success_count, failed_count)
+        self.run.set_progress(0, total_tasks, category='annotate_task_data')
+        self.run.log_message('Annotating data to tasks using inference...')
+
+        # Process each task
+        for task_id in task_ids:
+            try:
+                result = self._process_single_task(client, task_id, task_params, None, AnnotationMethod.INFERENCE)
+                if result['success']:
+                    success_count += 1
+                else:
+                    failed_count += 1
+
+                current_progress += 1
+                self._update_metrics(total_tasks, success_count, failed_count)
+                self.run.set_progress(current_progress, total_tasks, category='annotate_task_data')
+
+            except Exception as e:
+                self.run.log_message(f'Failed to process task {task_id}: {str(e)}')
+                self.run.log_annotate_task_data({'task_id': task_id, 'error': str(e)}, AnnotateTaskDataStatus.FAILED)
+                failed_count += 1
+                current_progress += 1
+                self._update_metrics(total_tasks, success_count, failed_count)
+                self.run.set_progress(current_progress, total_tasks, category='annotate_task_data')
+
+        # Finalize progress
+        self.run.set_progress(total_tasks, total_tasks, category='annotate_task_data')
+        self.run.log_message(f'Inference annotation completed. Success: {success_count}, Failed: {failed_count}')

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

@@ -6,3 +6,19 @@ class AnnotationToTask:
             run: Plugin run object.
         """
         self.run = run
+
+    def convert_data_from_file(self, data: dict):
+        """Convert the data from a file to a task object.
+
+        Args:
+            data: Converted data.
+        """
+        return data
+
+    def convert_data_from_inference(self, data: dict):
+        """Convert the data from inference result to a task object.
+
+        Args:
+            data: Converted data.
+        """
+        return data

synapse_sdk/plugins/categories/upload/actions/upload.py

@@ -203,7 +203,18 @@ class UploadAction(Action):
             'proportion': 40,
         },
     }
-    metrics_categories = {'data_file', 'data_unit'}
+    metrics_categories = {
+        'data_file': {
+            'stand_by': 0,
+            'failed': 0,
+            'success': 0,
+        },
+        'data_unit': {
+            'stand_by': 0,
+            'failed': 0,
+            'success': 0,
+        },
+    }
 
     def get_uploader(self, path, file_specification, organized_files):
         """Get uploader from entrypoint."""

synapse_sdk/plugins/models.py

@@ -128,7 +128,10 @@ class Run:
         self.set_logger()
 
     def set_logger(self):
-        kwargs = {'progress_categories': self.context['progress_categories']}
+        kwargs = {
+            'progress_categories': self.context['progress_categories'],
+            'metrics_categories': self.context['metrics_categories'],
+        }
 
         if self.job_id:
             self.logger = BackendLogger(self.client, self.job_id, **kwargs)

synapse_sdk/utils/converters/__init__.py

@@ -48,7 +48,7 @@ class BaseConverter:
         else:
             required_dirs = {
                 'json': os.path.join(self.root_dir, 'json'),
-                'original_file': os.path.join(self.root_dir, 'original_file'),
+                'original_files': os.path.join(self.root_dir, 'original_files'),
             }
             self._validate_required_dirs(required_dirs)
             splits['root'] = self.root_dir
@@ -60,10 +60,10 @@ class BaseConverter:
         if split:
             split_dir = os.path.join(self.root_dir, split)
             self.json_dir = os.path.join(split_dir, 'json')
-            self.original_file_dir = os.path.join(split_dir, 'original_file')
+            self.original_file_dir = os.path.join(split_dir, 'original_files')
         else:
             self.json_dir = os.path.join(self.root_dir, 'json')
-            self.original_file_dir = os.path.join(self.root_dir, 'original_file')
+            self.original_file_dir = os.path.join(self.root_dir, 'original_files')
 
 
 class FromDMConverter(BaseConverter):
@@ -185,7 +185,7 @@ class ToDMConverter(BaseConverter):
             for split, img_dict in self.converted_data.items():
                 split_dir = os.path.join(output_dir, split)
                 json_dir = os.path.join(split_dir, 'json')
-                original_file_dir = os.path.join(split_dir, 'original_file')
+                original_file_dir = os.path.join(split_dir, 'original_files')
                 self.ensure_dir(json_dir)
                 self.ensure_dir(original_file_dir)
                 for img_filename, (dm_json, img_src_path) in img_dict.items():
@@ -196,7 +196,7 @@ class ToDMConverter(BaseConverter):
                         shutil.copy(img_src_path, os.path.join(original_file_dir, img_filename))
         else:
             json_dir = os.path.join(output_dir, 'json')
-            original_file_dir = os.path.join(output_dir, 'original_file')
+            original_file_dir = os.path.join(output_dir, 'original_files')
             self.ensure_dir(json_dir)
             self.ensure_dir(original_file_dir)
             for img_filename, (dm_json, img_src_path) in self.converted_data.items():
@@ -205,4 +205,5 @@ class ToDMConverter(BaseConverter):
                     json.dump(dm_json, jf, indent=2, ensure_ascii=False)
                 if img_src_path and os.path.exists(img_src_path):
                     shutil.copy(img_src_path, os.path.join(original_file_dir, img_filename))
+
         print(f'[DM] Data exported to {output_dir}')

synapse_sdk/utils/converters/coco/from_dm.py

@@ -11,7 +11,7 @@ from tqdm import tqdm
 from synapse_sdk.utils.converters import FromDMConverter
 
 
-class DMToCOCOConverter(FromDMConverter):
+class FromDMToCOCOConverter(FromDMConverter):
     """Convert DM (Data Manager) format annotations to COCO format.
     Designed for easy future extensibility to handle various data types.
     """
@@ -242,11 +242,11 @@ class DMToCOCOConverter(FromDMConverter):
             for split, coco_data in self.converted_data.items():
                 split_output_dir = os.path.join(output_dir, split)
                 self._save_annotations_and_images(
-                    coco_data, split_output_dir, os.path.join(self.root_dir, split, 'original_file')
+                    coco_data, split_output_dir, os.path.join(self.root_dir, split, 'original_files')
                 )
         else:
             self._save_annotations_and_images(
-                self.converted_data, output_dir, os.path.join(self.root_dir, 'original_file')
+                self.converted_data, output_dir, os.path.join(self.root_dir, 'original_files')
             )
 
     def _save_annotations_and_images(self, coco_data, output_dir, original_file_dir):

synapse_sdk/utils/converters/yolo/from_dm.py

@@ -0,0 +1,296 @@
+import json
+import os
+import shutil
+from glob import glob
+from typing import Any, Dict, List, Optional, Union
+
+from PIL import Image
+
+from synapse_sdk.utils.converters import FromDMConverter
+
+
+class FromDMToYOLOConverter(FromDMConverter):
+    """Convert DM dataset format to YOLO format."""
+
+    IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
+
+    def __init__(self, root_dir: str, is_categorized_dataset: bool = False):
+        super().__init__(root_dir, is_categorized_dataset)
+        self.class_names: List[str] = []
+        self.class_map: Dict[str, int] = {}
+        self.dataset_yaml_content: str = ''
+
+    @staticmethod
+    def get_all_classes(list_of_dirs: List[str]) -> List[str]:
+        """Collect all unique class names from all splits or the root."""
+        classes = set()
+        for d in list_of_dirs:
+            if not d or not os.path.isdir(d):
+                continue
+            json_dir = os.path.join(d, 'json') if os.path.isdir(os.path.join(d, 'json')) else d
+            for jfile in glob(os.path.join(json_dir, '*.json')):
+                with open(jfile, encoding='utf-8') as jf:
+                    data = json.load(jf)
+                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'])
+        return sorted(list(classes))
+
+    @staticmethod
+    def get_image_size(image_path: str):
+        with Image.open(image_path) as img:
+            return img.size
+
+    @staticmethod
+    def polygon_to_bbox(polygon: list):
+        """Convert polygon points to bounding box [cx, cy, w, h]."""
+        if not polygon or len(polygon) == 0:
+            return None
+        xs = [p[0] for p in polygon]
+        ys = [p[1] for p in polygon]
+        x_min, y_min = min(xs), min(ys)
+        x_max, y_max = max(xs), max(ys)
+        cx = (x_min + x_max) / 2
+        cy = (y_min + y_max) / 2
+        w = x_max - x_min
+        h = y_max - y_min
+        return [cx, cy, w, h]
+
+    @staticmethod
+    def keypoints_to_yolo_string(keypoints: list, width: int, height: int):
+        """Convert keypoints to normalized YOLO keypoint format string (x1 y1 v1 x2 y2 v2 ...)."""
+        kp_strs = []
+        for kp in keypoints:
+            # kp: [x, y, visible]
+            x, y, v = kp
+            x = x / width
+            y = y / height
+            kp_strs.extend([f'{x:.6f}', f'{y:.6f}', str(v)])
+        return ' '.join(kp_strs)
+
+    def _convert_split_dir(self, split_dir: str, split_name: str) -> List[Dict[str, Any]]:
+        """Convert one split folder to YOLO format."""
+        if not self.class_map:
+            raise ValueError('class_map is not initialized. Ensure get_all_classes() is called before this method.')
+
+        json_dir = os.path.join(split_dir, 'json')
+        img_dir = os.path.join(split_dir, 'original_files')
+        entries = []
+        for jfile in glob(os.path.join(json_dir, '*.json')):
+            base = os.path.splitext(os.path.basename(jfile))[0]
+            found_img = None
+            for ext in self.IMG_EXTENSIONS:
+                img_path = os.path.join(img_dir, base + ext)
+                if os.path.exists(img_path):
+                    found_img = img_path
+                    break
+            if not found_img:
+                print(f'[{split_name}] Image for {base} not found, skipping.')
+                continue
+            width, height = self.get_image_size(found_img)
+            with open(jfile, encoding='utf-8') as jf:
+                data = json.load(jf)
+            img_ann = data['images'][0]
+            label_lines = []
+
+            # bbox
+            if 'bounding_box' in img_ann:
+                for box in img_ann['bounding_box']:
+                    cidx = self.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']:
+                    cidx = self.class_map[poly['classification']]
+                    bbox = self.polygon_to_bbox(poly['data'])
+                    if bbox is None:
+                        print(f'[{split_name}] Polygon for {base} is empty, skipping this polygon.')
+                        continue
+                    cx, cy, w, h = bbox
+                    cx /= width
+                    cy /= height
+                    w /= width
+                    h /= height
+                    label_lines.append(f'{cidx} {cx:.6f} {cy:.6f} {w:.6f} {h:.6f}')
+
+            # keypoint
+            if 'keypoint' in img_ann:
+                for kp in img_ann['keypoint']:
+                    cidx = self.class_map[kp['classification']]
+                    # Assume bounding box exists for keypoint, or fallback to full image
+                    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:
+                        # fallback to the whole image
+                        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}')
+
+            entries.append({
+                'img_path': found_img,
+                'img_name': os.path.basename(found_img),
+                'label_name': base + '.txt',
+                'label_lines': label_lines,
+            })
+        return entries
+
+    def _convert_root_dir(self) -> List[Dict[str, Any]]:
+        """Convert non-categorized dataset to YOLO format."""
+        json_dir = os.path.join(self.root_dir, 'json')
+        img_dir = os.path.join(self.root_dir, 'original_files')
+        entries = []
+        for jfile in glob(os.path.join(json_dir, '*.json')):
+            base = os.path.splitext(os.path.basename(jfile))[0]
+            found_img = None
+            for ext in self.IMG_EXTENSIONS:
+                img_path = os.path.join(img_dir, base + ext)
+                if os.path.exists(img_path):
+                    found_img = img_path
+                    break
+            if not found_img:
+                print(f'[single] Image for {base} not found, skipping.')
+                continue
+            width, height = self.get_image_size(found_img)
+            with open(jfile, encoding='utf-8') as jf:
+                data = json.load(jf)
+            img_ann = data['images'][0]
+            label_lines = []
+
+            # bbox
+            if 'bounding_box' in img_ann:
+                for box in img_ann['bounding_box']:
+                    cidx = self.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']:
+                    cidx = self.class_map[poly['classification']]
+                    bbox = self.polygon_to_bbox(poly['data'])
+                    if bbox is None:
+                        print(f'[single] Polygon for {base} is empty, skipping this polygon.')
+                        continue
+                    cx, cy, w, h = bbox
+                    cx /= width
+                    cy /= height
+                    w /= width
+                    h /= height
+                    label_lines.append(f'{cidx} {cx:.6f} {cy:.6f} {w:.6f} {h:.6f}')
+
+            # keypoint
+            if 'keypoint' in img_ann:
+                for kp in img_ann['keypoint']:
+                    cidx = self.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}')
+
+            entries.append({
+                'img_path': found_img,
+                'img_name': os.path.basename(found_img),
+                'label_name': base + '.txt',
+                'label_lines': label_lines,
+            })
+        return entries
+
+    def convert(self) -> Union[Dict[str, List[Dict[str, Any]]], List[Dict[str, Any]]]:
+        """Convert DM format to YOLO format (categorized split or not).
+
+        Returns:
+            - If categorized: dict {split: list of entries}
+            - If not: list of entries
+        """
+        # Prepare dataset.yaml content (for save_to_folder)
+        yaml_lines = [
+            'path: ' + self.root_dir,
+        ]
+
+        if self.is_categorized_dataset:
+            splits = self._validate_splits(required_splits=['train', 'valid'], optional_splits=['test'])
+            self.class_names = self.get_all_classes(list(splits.values()))
+            self.class_map = {name: idx for idx, name in enumerate(self.class_names)}
+            result = {}
+            for split, split_dir in splits.items():
+                result[split] = self._convert_split_dir(split_dir, split)
+            self.converted_data = result
+
+            yaml_lines.append('train: train/images')
+            yaml_lines.append('val: valid/images')
+            if 'test' in splits:
+                yaml_lines.append('test: test/images')
+        else:
+            self._validate_splits(required_splits=[], optional_splits=[])
+            self.class_names = self.get_all_classes([self.root_dir])
+            self.class_map = {name: idx for idx, name in enumerate(self.class_names)}
+            result = self._convert_root_dir()
+            self.converted_data = result
+
+        yaml_lines += ['', f'nc: {len(self.class_names)}', f'names: {self.class_names}', '']
+        self.dataset_yaml_content = '\n'.join(yaml_lines)
+        return result
+
+    def save_to_folder(self, output_dir: Optional[str] = None) -> None:
+        """Save converted YOLO data to the specified folder."""
+        output_dir = output_dir or self.root_dir
+        self.ensure_dir(output_dir)
+        if self.converted_data is None:
+            self.converted_data = self.convert()
+
+        if self.is_categorized_dataset:
+            for split, entries in self.converted_data.items():
+                split_imgs = os.path.join(output_dir, split, 'images')
+                split_labels = os.path.join(output_dir, split, 'labels')
+                self.ensure_dir(split_imgs)
+                self.ensure_dir(split_labels)
+                for entry in entries:
+                    shutil.copy(entry['img_path'], os.path.join(split_imgs, entry['img_name']))
+                    with open(os.path.join(split_labels, entry['label_name']), 'w', encoding='utf-8') as f:
+                        f.write('\n'.join(entry['label_lines']))
+        else:
+            imgs_dir = os.path.join(output_dir, 'images')
+            labels_dir = os.path.join(output_dir, 'labels')
+            self.ensure_dir(imgs_dir)
+            self.ensure_dir(labels_dir)
+            for entry in self.converted_data:
+                shutil.copy(entry['img_path'], os.path.join(imgs_dir, entry['img_name']))
+                with open(os.path.join(labels_dir, entry['label_name']), 'w', encoding='utf-8') as f:
+                    f.write('\n'.join(entry['label_lines']))
+
+        with open(os.path.join(output_dir, 'dataset.yaml'), 'w', encoding='utf-8') as f:
+            f.write(self.dataset_yaml_content)
+        with open(os.path.join(output_dir, 'classes.txt'), 'w', encoding='utf-8') as f:
+            for c in self.class_names:
+                f.write(f'{c}\n')
+        print(f'YOLO data exported to {output_dir}')

{synapse_sdk-1.0.0a70.dist-info → synapse_sdk-1.0.0a72.dist-info}/METADATA

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

{synapse_sdk-1.0.0a70.dist-info → synapse_sdk-1.0.0a72.dist-info}/RECORD

@@ -4,7 +4,7 @@ locale/ko/LC_MESSAGES/messages.mo,sha256=7HJEJA0wKlN14xQ5VF4FCNet54tjw6mfWYj3IaB
 locale/ko/LC_MESSAGES/messages.po,sha256=TFii_RbURDH-Du_9ZQf3wNh-2briGk1IqY33-9GKrMU,1126
 synapse_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/i18n.py,sha256=VXMR-Zm_1hTAg9iPk3YZNNq-T1Bhx1J2fEtRT6kyYbg,766
-synapse_sdk/loggers.py,sha256=hi-m5y4x0OcR2Esf7o849fWpdKrzCGOR4AxazbB7ShE,6528
+synapse_sdk/loggers.py,sha256=xK48h3ZaDDZLaF-qsdnv1-6-4vw_cYlgpSCKHYUQw1g,6549
 synapse_sdk/types.py,sha256=khzn8KpgxFdn1SrpbcuX84m_Md1Mz_HIoUoPq8uok40,698
 synapse_sdk/cli/__init__.py,sha256=RLZwqbtoC90-tw_2ErakY8-GxSNf6Ms2lNePBd_y-9U,9694
 synapse_sdk/cli/config.py,sha256=ooIHI7ZDA1yLtisxk_Xn1ptz4sM5j7TDivxaPvBUONE,11886
@@ -108,7 +108,7 @@ synapse_sdk/devtools/web/src/views/PluginView.jsx,sha256=_-V8elSiEtsvKECeROtQopS
 synapse_sdk/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/enums.py,sha256=ibixwqA3sCNSriG1jAtL54JQc_Zwo3MufwYUqGhVncc,523
 synapse_sdk/plugins/exceptions.py,sha256=Qs7qODp_RRLO9y2otU2T4ryj5LFwIZODvSIXkAh91u0,691
-synapse_sdk/plugins/models.py,sha256=dte0Thx4O8KS5WKrtERbtOmyZ85MG_TFqE6FUCplkjk,4645
+synapse_sdk/plugins/models.py,sha256=AKZfVT6hsVEklcEDnHwoVAwvLxydMibfeJetug3Qk0U,4738
 synapse_sdk/plugins/upload.py,sha256=VJOotYMayylOH0lNoAGeGHRkLdhP7jnC_A0rFQMvQpQ,3228
 synapse_sdk/plugins/utils.py,sha256=4_K6jIl0WrsXOEhFp94faMOriSsddOhIiaXcawYYUUA,3300
 synapse_sdk/plugins/categories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -125,7 +125,7 @@ synapse_sdk/plugins/categories/data_validation/templates/plugin/validation.py,sh
 synapse_sdk/plugins/categories/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/export/enums.py,sha256=gtyngvQ1DKkos9iKGcbecwTVQQ6sDwbrBPSGPNb5Am0,127
 synapse_sdk/plugins/categories/export/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synapse_sdk/plugins/categories/export/actions/export.py,sha256=2lIjur8EiwTB9sc16FV8ZaPXFxUtGRPx9hreG_DKLQA,10483
+synapse_sdk/plugins/categories/export/actions/export.py,sha256=buCpjRPZ-QPfEANKrSopKjCPHadjF1_A0eAkoezaAFA,10688
 synapse_sdk/plugins/categories/export/templates/config.yaml,sha256=N7YmnFROb3s3M35SA9nmabyzoSb5O2t2TRPicwFNN2o,56
 synapse_sdk/plugins/categories/export/templates/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/export/templates/plugin/export.py,sha256=zG8mSn7ZGIj8cttWmb7GEPcGgQRbZ97brJCzkuK7RP8,6106
@@ -153,11 +153,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=lJ9okNG8oFOXsPnng4gzl_U-bKL-hanCWv8bW3EBna0,15454
+synapse_sdk/plugins/categories/pre_annotation/actions/to_task.py,sha256=7w7CLHrsOjVC_qBjaPA1Vz2L0jyRFNsg05pS72cAr7Y,23331
 synapse_sdk/plugins/categories/pre_annotation/templates/config.yaml,sha256=4SKJe2gF8UCi3oD0kV8B4M2MkYcosz5GZzzAjAg3slc,508
 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=fgmTNaPgk8MnElEds4A6LiSmktNTVTNR7jO7dM7FwbI,223
+synapse_sdk/plugins/categories/pre_annotation/templates/plugin/to_task.py,sha256=0j01vFZYkaAw8mtf6HYfun3IUDlryTexqvss_JZtc-Y,618
 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
@@ -166,7 +166,7 @@ synapse_sdk/plugins/categories/smart_tool/templates/plugin/__init__.py,sha256=47
 synapse_sdk/plugins/categories/smart_tool/templates/plugin/auto_label.py,sha256=eevNg0nOcYFR4z_L_R-sCvVOYoLWSAH1jwDkAf3YCjY,320
 synapse_sdk/plugins/categories/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/upload/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synapse_sdk/plugins/categories/upload/actions/upload.py,sha256=YozR4WHDnoFQBth9hZoOYLLrMVtjrA9EFwLwQKqUK-M,18516
+synapse_sdk/plugins/categories/upload/actions/upload.py,sha256=cO0Hl6CyQm3MLVxmy_3LN-X58flCJUh_fJjJmh7Qg3U,18721
 synapse_sdk/plugins/categories/upload/templates/config.yaml,sha256=kwHNWHFYbzDi1mEh40KozatPZbZGH44dlP0t0J7ejJw,483
 synapse_sdk/plugins/categories/upload/templates/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/upload/templates/plugin/upload.py,sha256=IZU4sdSMSLKPCtlNqF7DP2howTdYR6hr74HCUZsGdPk,1559
@@ -192,10 +192,12 @@ synapse_sdk/utils/http.py,sha256=yRxYfru8tMnBVeBK-7S0Ga13yOf8oRHquG5e8K_FWcI,475
 synapse_sdk/utils/module_loading.py,sha256=chHpU-BZjtYaTBD_q0T7LcKWtqKvYBS4L0lPlKkoMQ8,1020
 synapse_sdk/utils/network.py,sha256=WI8qn6KlKpHdMi45V57ofKJB8zusJrbQsxT74LwVfsY,1000
 synapse_sdk/utils/string.py,sha256=rEwuZ9SAaZLcQ8TYiwNKr1h2u4CfnrQx7SUL8NWmChg,216
-synapse_sdk/utils/converters/__init__.py,sha256=7Lc8PeHGKKRlfhIyBbWXa258ha6qOcZCywGleFwD47E,9919
+synapse_sdk/utils/converters/__init__.py,sha256=jy-BxGUe1NOxQ0g8s9HNoPSYM2Xeq4Rd0vk8HDvFOhs,9926
 synapse_sdk/utils/converters/coco/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synapse_sdk/utils/converters/coco/from_dm.py,sha256=GH_y0zOYczbwByDusC4JiBl1M3utxpBYit7E_px7F-U,9620
+synapse_sdk/utils/converters/coco/from_dm.py,sha256=78aJ_O2_hmkQQ96nrjHY38roETWfBZB8GRHDn7qKEls,9626
 synapse_sdk/utils/converters/coco/to_dm.py,sha256=Ve8LrcKVlzNysam3fidcgP5fdm0_UGbBgSPoj2dT_JA,4906
+synapse_sdk/utils/converters/yolo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse_sdk/utils/converters/yolo/from_dm.py,sha256=e9u4CM4gWnh9_EzYiA-EqL8RICZo5NafWXzaqnrIrdU,12600
 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
@@ -207,9 +209,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.0a70.dist-info/licenses/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
-synapse_sdk-1.0.0a70.dist-info/METADATA,sha256=3Q2nmsvMEo9MgyHoxZMPFWQics_W5fx4VE16z-Nuq14,1130
-synapse_sdk-1.0.0a70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-synapse_sdk-1.0.0a70.dist-info/entry_points.txt,sha256=VNptJoGoNJI8yLXfBmhgUefMsmGI0m3-0YoMvrOgbxo,48
-synapse_sdk-1.0.0a70.dist-info/top_level.txt,sha256=ytgJMRK1slVOKUpgcw3LEyHHP7S34J6n_gJzdkcSsw8,12
-synapse_sdk-1.0.0a70.dist-info/RECORD,,
+synapse_sdk-1.0.0a72.dist-info/licenses/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
+synapse_sdk-1.0.0a72.dist-info/METADATA,sha256=1tbrM3SJ6aPgNShk_AEYZNYLZ2i8iencEXohtAvoVG0,1130
+synapse_sdk-1.0.0a72.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+synapse_sdk-1.0.0a72.dist-info/entry_points.txt,sha256=VNptJoGoNJI8yLXfBmhgUefMsmGI0m3-0YoMvrOgbxo,48
+synapse_sdk-1.0.0a72.dist-info/top_level.txt,sha256=ytgJMRK1slVOKUpgcw3LEyHHP7S34J6n_gJzdkcSsw8,12
+synapse_sdk-1.0.0a72.dist-info/RECORD,,