synapse-sdk 1.0.0a73__py3-none-any.whl → 1.0.0a75__py3-none-any.whl

synapse_sdk/utils/converters/pascal/from_dm.py

@@ -0,0 +1,177 @@
+import json
+import os
+import shutil
+import xml.etree.ElementTree as ET
+from glob import glob
+from typing import Any, List, Optional
+
+from PIL import Image
+
+from synapse_sdk.utils.converters import FromDMConverter
+
+
+class FromDMToPascalConverter(FromDMConverter):
+    """Convert DM format to Pascal VOC 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 = set()
+
+    def find_image_for_base(self, img_dir: str, base: str) -> Optional[str]:
+        """Find the image file for a given base name in the specified directory."""
+        for ext in self.IMG_EXTENSIONS:
+            img_path = os.path.join(img_dir, base + ext)
+            if os.path.exists(img_path):
+                return img_path
+        return None
+
+    def build_pascal_xml(self, img_filename: str, img_size: tuple, objects: List[dict]) -> ET.ElementTree:
+        """Build a Pascal VOC XML tree from image filename, size, and objects."""
+        folder = 'Images'
+        width, height, depth = img_size
+        annotation = ET.Element('annotation')
+        ET.SubElement(annotation, 'folder').text = folder
+        ET.SubElement(annotation, 'filename').text = img_filename
+        ET.SubElement(annotation, 'path').text = img_filename
+        source = ET.SubElement(annotation, 'source')
+        ET.SubElement(source, 'database').text = 'Unknown'
+        size = ET.SubElement(annotation, 'size')
+        ET.SubElement(size, 'width').text = str(width)
+        ET.SubElement(size, 'height').text = str(height)
+        ET.SubElement(size, 'depth').text = str(depth)
+        ET.SubElement(annotation, 'segmented').text = '0'
+        for obj in objects:
+            obj_elem = ET.SubElement(annotation, 'object')
+            ET.SubElement(obj_elem, 'name').text = obj['name']
+            ET.SubElement(obj_elem, 'pose').text = 'Unspecified'
+            ET.SubElement(obj_elem, 'truncated').text = '0'
+            ET.SubElement(obj_elem, 'difficult').text = '0'
+            bndbox = ET.SubElement(obj_elem, 'bndbox')
+            ET.SubElement(bndbox, 'xmin').text = str(obj['xmin'])
+            ET.SubElement(bndbox, 'ymin').text = str(obj['ymin'])
+            ET.SubElement(bndbox, 'xmax').text = str(obj['xmax'])
+            ET.SubElement(bndbox, 'ymax').text = str(obj['ymax'])
+        return ET.ElementTree(annotation)
+
+    def parse_dm_annotations(self, annotation: dict):
+        """Parse DM annotations and convert to Pascal VOC format."""
+        objects = []
+        # Only include bounding_box (Pascal VOC does not support polyline/keypoint by default)
+        if 'bounding_box' in annotation:
+            for box in annotation['bounding_box']:
+                class_name = box['classification']
+                x, y, w, h = box['data']
+                xmin = int(round(x))
+                ymin = int(round(y))
+                xmax = int(round(x + w))
+                ymax = int(round(y + h))
+                objects.append({'name': class_name, 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax})
+                self.class_names.add(class_name)
+        # polyline, keypoint 등은 무시
+        return objects
+
+    def _convert_split_dir(self, split_dir: str, split_name: str):
+        """Convert a split dir (train/valid/test) to list of (xml_tree, xml_filename, img_src, img_name)."""
+        json_dir = os.path.join(split_dir, 'json')
+        img_dir = os.path.join(split_dir, 'original_files')
+        results = []
+        for jfile in glob(os.path.join(json_dir, '*.json')):
+            base = os.path.splitext(os.path.basename(jfile))[0]
+            img_path = self.find_image_for_base(img_dir, base)
+            if not img_path:
+                print(f'[{split_name}] Image for {base} not found, skipping.')
+                continue
+            with open(jfile, encoding='utf-8') as jf:
+                data = json.load(jf)
+            img_ann = data['images'][0]
+            with Image.open(img_path) as img:
+                width, height = img.size
+                depth = len(img.getbands())
+            objects = self.parse_dm_annotations(img_ann)
+            xml_tree = self.build_pascal_xml(os.path.basename(img_path), (width, height, depth), objects)
+            xml_filename = base + '.xml'
+            results.append((xml_tree, xml_filename, img_path, os.path.basename(img_path)))
+        return results
+
+    def _convert_root_dir(self):
+        """Convert non-categorized dataset to list of (xml_tree, xml_filename, img_src, img_name)."""
+        json_dir = os.path.join(self.root_dir, 'json')
+        img_dir = os.path.join(self.root_dir, 'original_files')
+        results = []
+        for jfile in glob(os.path.join(json_dir, '*.json')):
+            base = os.path.splitext(os.path.basename(jfile))[0]
+            img_path = self.find_image_for_base(img_dir, base)
+            if not img_path:
+                print(f'[Pascal] Image for {base} not found, skipping.')
+                continue
+            with open(jfile, encoding='utf-8') as jf:
+                data = json.load(jf)
+            img_ann = data['images'][0]
+            with Image.open(img_path) as img:
+                width, height = img.size
+                depth = len(img.getbands())
+            objects = self.parse_dm_annotations(img_ann)
+            xml_tree = self.build_pascal_xml(os.path.basename(img_path), (width, height, depth), objects)
+            xml_filename = base + '.xml'
+            results.append((xml_tree, xml_filename, img_path, os.path.basename(img_path)))
+        return results
+
+    def convert(self) -> Any:
+        """Converts DM format to Pascal VOC format.
+
+        Returns:
+            - If categorized: dict {split: list of (xml_tree, xml_filename, img_src, img_name)}
+            - If not: list of (xml_tree, xml_filename, img_src, img_name)
+        """
+        self.class_names = set()
+        if self.is_categorized_dataset:
+            splits = self._validate_splits(['train', 'valid'], ['test'])
+            result = {}
+            for split, split_dir in splits.items():
+                result[split] = self._convert_split_dir(split_dir, split)
+            self.converted_data = result
+            return result
+        else:
+            self._validate_splits([], [])
+            result = self._convert_root_dir()
+            self.converted_data = result
+            return result
+
+    def save_to_folder(self, output_dir: Optional[str] = None):
+        """Save all Pascal VOC XML/Images to output_dir (Annotations, Images).
+        - If categorized: per split under output_dir/{split}/{Annotations, Images}
+        - If not: directly under output_dir/{Annotations, Images}
+        """
+        outdir = output_dir or self.root_dir
+        self.ensure_dir(outdir)
+        if self.converted_data is None:
+            self.converted_data = self.convert()
+
+        if self.is_categorized_dataset:
+            for split, entries in self.converted_data.items():
+                ann_dir = os.path.join(outdir, split, 'Annotations')
+                img_dir = os.path.join(outdir, split, 'Images')
+                os.makedirs(ann_dir, exist_ok=True)
+                os.makedirs(img_dir, exist_ok=True)
+                for xml_tree, xml_filename, img_src, img_name in entries:
+                    xml_tree.write(os.path.join(ann_dir, xml_filename), encoding='utf-8', xml_declaration=True)
+                    dst_path = os.path.join(img_dir, img_name)
+                    if os.path.abspath(img_src) != os.path.abspath(dst_path):
+                        shutil.copy(img_src, dst_path)
+        else:
+            ann_dir = os.path.join(outdir, 'Annotations')
+            img_dir = os.path.join(outdir, 'Images')
+            os.makedirs(ann_dir, exist_ok=True)
+            os.makedirs(img_dir, exist_ok=True)
+            for xml_tree, xml_filename, img_src, img_name in self.converted_data:
+                xml_tree.write(os.path.join(ann_dir, xml_filename), encoding='utf-8', xml_declaration=True)
+                dst_path = os.path.join(img_dir, img_name)
+                if os.path.abspath(img_src) != os.path.abspath(dst_path):
+                    shutil.copy(img_src, dst_path)
+        # Save classes.txt
+        with open(os.path.join(outdir, 'classes.txt'), 'w', encoding='utf-8') as f:
+            for c in sorted(self.class_names):
+                f.write(f'{c}\n')
+        print(f'Pascal VOC data exported to {outdir}')

synapse_sdk/utils/converters/pascal/to_dm.py

@@ -0,0 +1,135 @@
+import os
+import xml.etree.ElementTree as ET
+from typing import Any, Dict, List, Optional, Tuple
+
+from PIL import Image
+
+from synapse_sdk.utils.converters import ToDMConverter
+
+
+class PascalToDMConverter(ToDMConverter):
+    """Convert Pascal VOC formatted datasets to DM format."""
+
+    IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
+
+    def convert(self):
+        """Convert the Pascal VOC dataset to DM format."""
+        if self.is_categorized_dataset:
+            splits = self._validate_splits(['train', 'valid'], ['test'])
+            all_split_data = {}
+            for split, split_dir in splits.items():
+                split_data = self._convert_pascal_split_to_dm(split_dir)
+                all_split_data[split] = split_data
+            self.converted_data = all_split_data
+            return all_split_data
+        else:
+            split_data = self._convert_pascal_split_to_dm(self.root_dir)
+            self.converted_data = split_data
+            return split_data
+
+    def _find_image_path(self, images_dir: str, filename: str) -> Optional[str]:
+        """Find the image file in the specified directory."""
+        img_path = os.path.join(images_dir, filename)
+        if os.path.exists(img_path):
+            return img_path
+        base = os.path.splitext(filename)[0]
+        for ext in self.IMG_EXTENSIONS:
+            img_path = os.path.join(images_dir, base + ext)
+            if os.path.exists(img_path):
+                return img_path
+        return None
+
+    @staticmethod
+    def _get_image_size(image_path: str) -> Tuple[int, int]:
+        """Get the size of the image."""
+        with Image.open(image_path) as img:
+            return img.size
+
+    def _parse_pascal_xml(self, xml_path: str) -> Tuple[str, List[Dict[str, Any]]]:
+        """Parse a Pascal VOC XML file and return the filename and objects."""
+        tree = ET.parse(xml_path)
+        root = tree.getroot()
+        filename_elem = root.find('filename')
+        filename = filename_elem.text if filename_elem is not None else None
+        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]})
+        return filename, objects
+
+    def _convert_pascal_split_to_dm(self, split_dir: str) -> Dict[str, Any]:
+        """Convert a single Pascal VOC split directory to DM format."""
+        annotations_dir = None
+        for candidate in ['Annotations', 'annotations']:
+            candidate_path = os.path.join(split_dir, candidate)
+            if os.path.isdir(candidate_path):
+                annotations_dir = candidate_path
+                break
+        if annotations_dir is None:
+            raise FileNotFoundError(
+                f"No annotations directory found in {split_dir} (tried 'Annotations', 'annotations')."
+            )
+        images_dir = None
+        for candidate in ['Images', 'images', 'JPEGImages']:
+            candidate_path = os.path.join(split_dir, candidate)
+            if os.path.isdir(candidate_path):
+                images_dir = candidate_path
+                break
+        if images_dir is None:
+            raise FileNotFoundError(
+                f"No images directory found in {split_dir} (tried 'Images', 'images', 'JPEGImages')."
+            )
+        result = {}
+        for xml_filename in os.listdir(annotations_dir):
+            if not xml_filename.endswith('.xml'):
+                continue
+            xml_path = os.path.join(annotations_dir, xml_filename)
+            try:
+                filename, objects = self._parse_pascal_xml(xml_path)
+                if filename is None:
+                    print(f'[WARNING] No filename found in {xml_filename}, skipping.')
+                    continue
+                img_path = self._find_image_path(images_dir, filename)
+                if img_path is None:
+                    print(f'[WARNING] Image not found for {filename}, skipping.')
+                    continue
+                # 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]}
+                result[os.path.basename(img_path)] = (dm_json, img_path)
+            except ET.ParseError as e:
+                print(f'[WARNING] Failed to parse {xml_filename}: {e}, skipping.')
+                continue
+            except Exception as e:
+                print(f'[WARNING] Error processing {xml_filename}: {e}, skipping.')
+                continue
+        return result

synapse_sdk/utils/converters/yolo/from_dm.py

@@ -58,6 +58,22 @@ class FromDMToYOLOConverter(FromDMConverter):
         h = y_max - y_min
         return [cx, cy, w, h]
 
+    @staticmethod
+    def polygon_to_yolo_string(polygon: list, width: int, height: int):
+        """Convert polygon points to normalized YOLO polygon format string (x1 y1 x2 y2 ...)."""
+        if not polygon or len(polygon) == 0:
+            return ''
+
+        coords = []
+        for point in polygon:
+            x, y = point
+            # Normalize coordinates to 0-1 range
+            x_norm = x / width
+            y_norm = y / height
+            coords.extend([f'{x_norm:.6f}', f'{y_norm:.6f}'])
+
+        return ' '.join(coords)
+
     @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 ...)."""
@@ -112,16 +128,11 @@ class FromDMToYOLOConverter(FromDMConverter):
             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:
+                    poly_str = self.polygon_to_yolo_string(poly['data'], width, height)
+                    if poly_str:  # Only add if polygon is valid
+                        label_lines.append(f'{cidx} {poly_str}')
+                    else:
                         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:
@@ -189,16 +200,11 @@ class FromDMToYOLOConverter(FromDMConverter):
             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:
+                    poly_str = self.polygon_to_yolo_string(poly['data'], width, height)
+                    if poly_str:  # Only add if polygon is valid
+                        label_lines.append(f'{cidx} {poly_str}')
+                    else:
                         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:

synapse_sdk/utils/converters/yolo/to_dm.py

@@ -0,0 +1,185 @@
+import os
+from typing import Any, Dict, List, Tuple
+
+import yaml
+from PIL import Image
+
+from synapse_sdk.utils.converters import ToDMConverter
+
+
+class YOLOToDMConverter(ToDMConverter):
+    """Convert YOLO formatted datasets to DM format."""
+
+    IMG_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.bmp']
+
+    def convert(self):
+        """Convert YOLO dataset to DM format."""
+        if self.is_categorized_dataset:
+            splits = self._validate_splits(['train', 'valid'], ['test'])
+            all_split_data = {}
+            for split, split_dir in splits.items():
+                split_data = self._convert_yolo_split_to_dm(split_dir)
+                all_split_data[split] = split_data
+            self.converted_data = all_split_data
+            return all_split_data
+        else:
+            split_data = self._convert_yolo_split_to_dm(self.root_dir)
+            self.converted_data = split_data
+            return split_data
+
+    def _find_image_path(self, images_dir, base):
+        """Find the image file corresponding to the base name in the images directory."""
+        for ext in self.IMG_EXTENSIONS:
+            img_path = os.path.join(images_dir, base + ext)
+            if os.path.exists(img_path):
+                return img_path
+        return None
+
+    @staticmethod
+    def _get_image_size(image_path: str) -> Tuple[int, int]:
+        """Get the size of the image at the given path."""
+        with Image.open(image_path) as img:
+            return img.size
+
+    def _parse_yolo_line(self, line: str, class_names: List[str], img_size: Tuple[int, int]):
+        """Parse a single line from a YOLO label file."""
+        parts = line.strip().split()
+        if len(parts) < 5:
+            return None  # skip malformed
+
+        class_idx = int(parts[0])
+        class_name = class_names[class_idx] if class_idx < len(class_names) else f'class_{class_idx}'
+        img_w, img_h = img_size
+
+        # Check if it's a polygon (more than 5 values and even number of coordinates after class_id)
+        if len(parts) > 5 and (len(parts) - 1) % 2 == 0:
+            # Polygon format: class_id x1 y1 x2 y2 x3 y3 ... (normalized coordinates)
+            coords = []
+            for i in range(1, len(parts), 2):
+                x_norm = float(parts[i])
+                y_norm = float(parts[i + 1])
+                # Convert normalized coordinates to absolute coordinates
+                x_abs = int(x_norm * img_w)
+                y_abs = int(y_norm * img_h)
+                coords.append([x_abs, y_abs])
+
+            return {'type': 'polygon', 'classification': class_name, 'data': coords}
+
+        # Standard bounding box format
+        elif len(parts) == 5:
+            x_center, y_center, width, height = map(float, parts[1:5])
+
+            # Denormalize YOLO (x_center, y_center, w, h) to (left, top, w, h)
+            left = int((x_center - width / 2) * img_w)
+            top = int((y_center - height / 2) * img_h)
+            abs_w = int(width * img_w)
+            abs_h = int(height * img_h)
+
+            return {'type': 'bounding_box', 'classification': class_name, 'data': [left, top, abs_w, abs_h]}
+
+        # Keypoint format: class_id x_center y_center w h x1 y1 v1 x2 y2 v2 ...
+        elif len(parts) > 5 and (len(parts) - 5) % 3 == 0:
+            x_center, y_center, width, height = map(float, parts[1:5])
+
+            # Denormalize bounding box
+            left = int((x_center - width / 2) * img_w)
+            top = int((y_center - height / 2) * img_h)
+            abs_w = int(width * img_w)
+            abs_h = int(height * img_h)
+
+            keypoints = []
+            for i in range(5, len(parts), 3):
+                xk = int(float(parts[i]) * img_w)
+                yk = int(float(parts[i + 1]) * img_h)
+                vk = int(parts[i + 2])
+                keypoints.append([xk, yk, vk])
+
+            return {
+                'type': 'keypoint',
+                'classification': class_name,
+                'data': keypoints,
+                'bounding_box': [left, top, abs_w, abs_h],
+            }
+
+        return None
+
+    def _convert_yolo_split_to_dm(self, split_dir: str) -> Dict[str, Any]:
+        """Convert a single YOLO split directory to DM format."""
+        # Find image and label directories
+        images_dir = None
+        for candidate in ['images', 'img', 'imgs']:
+            candidate_path = os.path.join(split_dir, candidate)
+            if os.path.isdir(candidate_path):
+                images_dir = candidate_path
+                break
+        if images_dir is None:
+            raise FileNotFoundError(f"No images directory found in {split_dir} (tried 'images', 'img', 'imgs').")
+
+        labels_dir = os.path.join(split_dir, 'labels')
+        if not os.path.isdir(labels_dir):
+            raise FileNotFoundError(f"No labels directory found in {split_dir} (expected 'labels').")
+
+        # Load dataset.yaml
+
+        dataset_yaml_path = os.path.join(self.root_dir, 'dataset.yaml')
+        if not os.path.exists(dataset_yaml_path):
+            raise FileNotFoundError(f'No dataset.yaml file found in {split_dir}.')
+        with open(dataset_yaml_path, 'r', encoding='utf-8') as f:
+            dataset_yaml = yaml.safe_load(f)
+            class_names = dataset_yaml.get('names', [])
+
+        # Build DM data
+        result = {}
+        for label_filename in os.listdir(labels_dir):
+            if not label_filename.endswith('.txt'):
+                continue
+            base = os.path.splitext(label_filename)[0]
+            img_path = self._find_image_path(images_dir, base)
+            if img_path is None:
+                print(f'[WARNING] Image not found for label {label_filename}, skipping.')
+                continue
+            img_size = self._get_image_size(img_path)
+            label_path = os.path.join(labels_dir, label_filename)
+            with open(label_path, 'r', encoding='utf-8') as f:
+                label_lines = [line.strip() for line in f 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]}
+            result[os.path.basename(img_path)] = (dm_json, img_path)
+        return result

synapse_sdk-1.0.0a75.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: synapse-sdk
+Version: 1.0.0a75
+Summary: synapse sdk
+Author-email: datamaker <developer@datamaker.io>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3
+Requires-Dist: click
+Requires-Dist: cookiecutter
+Requires-Dist: requests
+Requires-Dist: tqdm
+Requires-Dist: python-dotenv
+Requires-Dist: pyyaml
+Requires-Dist: pydantic
+Requires-Dist: pyjwt
+Requires-Dist: universal-pathlib
+Requires-Dist: fsspec[gcs,s3,sftp]
+Requires-Dist: inquirer
+Requires-Dist: pillow
+Provides-Extra: all
+Requires-Dist: ray[all]; extra == "all"
+Requires-Dist: python-nmap; extra == "all"
+Requires-Dist: hyperopt; extra == "all"
+Requires-Dist: bayesian-optimization==1.4.3; extra == "all"
+Provides-Extra: dashboard
+Requires-Dist: fastapi>=0.115.13; extra == "dashboard"
+Requires-Dist: uvicorn[standard]>=0.34.3; extra == "dashboard"
+Requires-Dist: websockets>=15.0.1; extra == "dashboard"
+Requires-Dist: aiofiles>=24.1.0; extra == "dashboard"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10.0; extra == "test"
+Requires-Dist: pytest-timeout>=2.1.0; extra == "test"
+Requires-Dist: pytest-xdist>=3.0.0; extra == "test"
+Requires-Dist: pytest-html>=3.1.0; extra == "test"
+Requires-Dist: pytest-json-report>=1.5.0; extra == "test"
+Requires-Dist: requests-mock>=1.10.0; extra == "test"
+Requires-Dist: responses>=0.25.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: license-file
+
+# 🧠 Synapse SDK
+
+![lint workflow](https://github.com/datamaker-kr/synapse-sdk/actions/workflows/lint.yml/badge.svg)
+![test workflow](https://github.com/datamaker-kr/synapse-sdk/actions/workflows/test.yml/badge.svg)
+
+A Python SDK for building and managing ML plugins, data annotation workflows, and AI agents.
+
+## ✨ Features
+
+- **🔌 Plugin System**: Create and manage ML plugins with categories like neural networks, data validation, and export tools
+- **🤖 Agent Management**: Backend and Ray-based agent clients for distributed AI workflows  
+- **🔄 Data Converters**: Convert between formats (COCO, Pascal VOC, YOLO) and annotation schemas
+- **🛠️ Development Tools**: Interactive web dashboard for monitoring and debugging
+- **⚡ CLI Interface**: Command-line tool for configuration, plugin management, and development
+
+## 🚀 Quick Start
+
+```bash
+pip install synapse-sdk
+synapse --help
+```
+
+## 📚 Documentation
+
+*Docs [https://docs.synapse.sh](https://docs.synapse.sh)*