synapse-sdk 1.0.0a48__tar.gz → 1.0.0a50__tar.gz

{synapse_sdk-1.0.0a48/synapse_sdk/plugins/templates/synapse-{{cookiecutter.plugin_code}}-plugin → synapse_sdk-1.0.0a50}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.1
+    rev: v0.11.10
     hooks:
       - id: ruff
         args: [ --fix ]

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0a48
+Version: 1.0.0a50
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT
@@ -22,6 +22,8 @@ Requires-Dist: fsspec[gcs,s3,sftp]
 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"
 Dynamic: license-file
 
 This is the SDK to develop synapse plugins

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/pyproject.toml

@@ -30,7 +30,9 @@ dynamic = ["version"]
 [project.optional-dependencies]
 all = [
     "ray[all]",
-    "python-nmap"
+    "python-nmap",
+    "hyperopt",
+    "bayesian-optimization==1.4.3"
 ]
 
 [project.scripts]

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/loggers.py

@@ -1,21 +1,48 @@
 import datetime
 import time
+from typing import Any, Dict
 
 from synapse_sdk.clients.exceptions import ClientError
 
 
 class BaseLogger:
+    """Base class for logging progress and events.
+
+    Args:
+        progress_record(dict): Progress record to track the progress of a task.
+        progress_categories: dict | None: List of categories for progress tracking.
+        metrics_categories: dict | None: List of categories for metrics tracking.
+        current_progress_category: str | None: Current progress category.
+        time_begin_per_category(dict): Dictionary to track the start time for each category.
+        metrics_record(dict): Dictionary to record metrics.
+    """
+
     progress_record = {}
+    metrics_record = {}
     progress_categories = None
-    current_category = None
+    metrics_categories = None
+    current_progress_category = None
     time_begin_per_category = {}
 
-    def __init__(self, progress_categories=None):
+    def __init__(self, progress_categories=None, metrics_categories=None):
+        # Setup progress categories
         self.progress_categories = progress_categories
         if progress_categories:
             self.progress_record['categories'] = progress_categories
 
-    def set_progress(self, current, total, category=None):
+        # Setup metrics categories
+        self.metrics_categories = metrics_categories
+        if metrics_categories:
+            self.metrics_record['categories'] = metrics_categories
+
+    def set_progress(self, current: int, total: int, category: str | None = None):
+        """Set progress for plugin run.
+
+        Args:
+            current(int): current progress value
+            total(int): total progress value
+            category(str | None): progress category
+        """
         assert 0 <= current <= total and total > 0
         assert category is not None or 'categories' not in self.progress_record
 
@@ -32,7 +59,7 @@ class BaseLogger:
         current_progress = {'percent': percent, 'time_remaining': time_remaining}
 
         if category:
-            self.current_category = category
+            self.current_progress_category = category
             self.progress_record['categories'][category].update(current_progress)
         else:
             self.progress_record.update(current_progress)
@@ -45,15 +72,15 @@ class BaseLogger:
 
             overall = 0
             for category, category_record in categories.items():
-                if category == self.current_category:
+                if category == self.current_progress_category:
                     break
                 overall += category_record['proportion']
 
-            category_record = categories[self.current_category]
+            category_record = categories[self.current_progress_category]
             category_percent = category_record.get('percent', 0)
             if not category_progress and 'percent' in category_record:
                 category_progress = {
-                    'category': self.current_category,
+                    'category': self.current_progress_category,
                     'percent': category_percent,
                     'time_remaining': category_record.get('time_remaining'),
                 }
@@ -68,6 +95,23 @@ class BaseLogger:
 
         return progress
 
+    def set_metrics(self, value: Dict[Any, Any], category: str):
+        """Set metrics for plugin run.
+
+        * Metrics which are representing the progress of the plugin run should be set in the metrics_record.
+
+        Args:
+            value(Dict[Any, Any]): metrics value
+            category(str): metrics category
+        """
+        assert category is not None and category != '', 'A category argument must be a non-empty string.'
+        assert isinstance(value, dict), f'A value argument must be a dictionary, but got {type(value).__name__}.'
+
+        if 'categories' not in self.metrics_record:
+            self.metrics_record['categories'] = {}
+
+        self.metrics_record['categories'][category] = value
+
     def log(self, action, data, file=None):
         raise NotImplementedError
 
@@ -77,6 +121,10 @@ class ConsoleLogger(BaseLogger):
         super().set_progress(current, total, category=category)
         print(self.get_current_progress())
 
+    def set_metrics(self, value: Dict[Any, Any], category: str):
+        super().set_metrics(value, category)
+        print(self.metrics_record)
+
     def log(self, action, data, file=None):
         print(action, data)
 
@@ -102,6 +150,16 @@ class BackendLogger(BaseLogger):
         except ClientError:
             pass
 
+    def set_metrics(self, value: Dict[Any, Any], category: str):
+        super().set_metrics(value, category)
+        try:
+            metrics_record = {
+                'record': self.metrics_record,
+            }
+            self.client.update_job(self.job_id, data={'metrics_record': metrics_record})
+        except ClientError:
+            pass
+
     def log(self, event, data, file=None):
         print(event, data)
 

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/plugins/categories/base.py

@@ -25,7 +25,8 @@ class Action:
         method (RunMethod): The method to run of the action.
         run_class (Run): The class to run the action.
         params_model (BaseModel): The model to validate the params.
-        progress_categories (List[str]): The categories to update the progress.
+        progress_categories (Dict[str] | None): The categories to update the progress.
+        metrics_categories (Dict[str] | None): The categories to update the metrics.
         params (Dict): The params to run the action.
         plugin_config (Dict): The plugin config.
         plugin_release (PluginRelease): The plugin release.
@@ -48,6 +49,7 @@ class Action:
     run_class = Run
     params_model = None
     progress_categories = None
+    metrics_categories = None
 
     # init 변수
     params = None
@@ -142,6 +144,7 @@ class Action:
         context = {
             'plugin_release': self.plugin_release,
             'progress_categories': self.progress_categories,
+            'metrics_categories': self.metrics_categories,
             'params': self.params,
             'envs': self.envs,
             'debug': self.debug,

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/plugins/categories/export/actions/export.py

@@ -27,6 +27,13 @@ class ExportRun(Run):
         error: str | None = None
         created: str
 
+    class MetricsRecord(BaseModel):
+        """Metrics record model."""
+
+        stand_by: int
+        failed: int
+        success: int
+
     def log_file(
         self, log_type: str, target_id: int, data_file_info: dict, status: ExportStatus, error: str | None = None
     ):
@@ -51,6 +58,16 @@ class ExportRun(Run):
             ).model_dump(),
         )
 
+    def log_metrics(self, record: MetricsRecord, category: str):
+        """Log export metrics.
+
+        Args:
+            record (MetricsRecord): The metrics record to log.
+            category (str): The category of the metrics.
+        """
+        record = self.MetricsRecord.model_validate(record)
+        self.set_metrics(value=record.dict(), category=category)
+
     def export_log_json_file(
         self,
         target_id: int,
@@ -263,6 +280,7 @@ class ExportAction(Action):
             'proportion': 100,
         }
     }
+    metrics_categories = {'data_file', 'original_file'}
 
     def get_filtered_results(self, filters, handler):
         """Get filtered target results."""

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/plugins/categories/export/templates/plugin/export.py

@@ -42,6 +42,8 @@ def export(run, export_items, path_root, **params):
     origin_files_output_path.mkdir(parents=True, exist_ok=True)
 
     total = params['count']
+    original_file_metrics_record = run.MetricsRecord(stand_by=total, success=0, failed=0)
+    data_file_metrics_record = run.MetricsRecord(stand_by=total, success=0, failed=0)
     # progress init
     run.set_progress(0, total, category='dataset_conversion')
     for no, export_item in enumerate(export_items, start=1):
@@ -56,12 +58,30 @@ def export(run, export_items, path_root, **params):
         if save_original_file_flag:
             if no == 1:
                 run.log_message('Saving original file.')
-            save_original_file(run, final_data, origin_files_output_path, errors_original_file_list)
+            original_status = save_original_file(run, final_data, origin_files_output_path, errors_original_file_list)
+
+            original_file_metrics_record.stand_by -= 1
+            if original_status == ExportStatus.FAILED:
+                original_file_metrics_record.failed += 1
+                continue
+            else:
+                original_file_metrics_record.success += 1
+
+        run.log_metrics(record=original_file_metrics_record, category='original_file')
 
         # Extract data as JSON files
         if no == 1:
             run.log_message('Saving json file.')
-        save_as_json(run, final_data, json_output_path, errors_json_file_list)
+        data_status = save_as_json(run, final_data, json_output_path, errors_json_file_list)
+
+        data_file_metrics_record.stand_by -= 1
+        if data_status == ExportStatus.FAILED:
+            data_file_metrics_record.failed += 1
+            continue
+        else:
+            data_file_metrics_record.success += 1
+
+        run.log_metrics(record=data_file_metrics_record, category='data_file')
 
     run.end_log()
 
@@ -89,7 +109,7 @@ def after_convert(data):
     return data
 
 
-def get_original_file_pathlib(files):
+def get_original_file_name(files):
     """Retrieve the original file path from the given file information.
 
     Args:
@@ -97,9 +117,9 @@ def get_original_file_pathlib(files):
                       original file path, metadata, etc.
 
     Returns:
-        pathlib.Path: The original file path extracted from the metadata.
+        file_name (str): The original file name extracted from the file information.
     """
-    return Path(files['meta']['path_original'])
+    return files['file_name_original']
 
 
 def save_original_file(run, result, base_path, error_file_list):
@@ -112,7 +132,7 @@ def save_original_file(run, result, base_path, error_file_list):
         error_file_list (list): A list to store error files.
     """
     file_url = result['files']['url']
-    file_name = get_original_file_pathlib(result['files']).name
+    file_name = get_original_file_name(result['files'])
     response = requests.get(file_url)
     file_info = {'file_name': file_name}
     error_msg = ''
@@ -126,6 +146,7 @@ def save_original_file(run, result, base_path, error_file_list):
         status = ExportStatus.FAILED
 
     run.export_log_original_file(result['id'], file_info, status, error_msg)
+    return status
 
 
 def save_as_json(run, result, base_path, error_file_list):
@@ -138,7 +159,7 @@ def save_as_json(run, result, base_path, error_file_list):
         error_file_list (list): A list to store error files.
     """
     # Default save file name: original file name
-    file_name = get_original_file_pathlib(result['files']).stem
+    file_name = Path(get_original_file_name(result['files'])).stem
     json_data = result['data']
     file_info = {'file_name': f'{file_name}.json'}
     error_msg = ''
@@ -152,3 +173,4 @@ def save_as_json(run, result, base_path, error_file_list):
         status = ExportStatus.FAILED
 
     run.export_log_json_file(result['id'], file_info, status, error_msg)
+    return status

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/plugins/categories/neural_net/actions/train.py

@@ -21,9 +21,9 @@ class TrainRun(Run):
         # TODO validate input via plugin config
         self.log('metric', {'category': category, 'key': key, 'value': value, 'metrics': metrics})
 
-    def log_visualization(self, category, group, image, **meta):
+    def log_visualization(self, category, group, index, image, **meta):
         # TODO validate input via plugin config
-        self.log('visualization', {'category': category, 'group': group, **meta}, file=image)
+        self.log('visualization', {'category': category, 'group': group, 'index': index, **meta}, file=image)
 
 
 class Hyperparameter(BaseModel):

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/plugins/categories/neural_net/actions/tune.py

@@ -22,11 +22,23 @@ class TuneRun(TrainRun):
     checkpoint_output = None
 
 
+class SearchAlgo(BaseModel):
+    name: str
+    points_to_evaluate: Optional[dict] = None
+
+
+class Scheduler(BaseModel):
+    name: str
+    options: Optional[str] = None
+
+
 class TuneConfig(BaseModel):
     mode: Optional[str] = None
     metric: Optional[str] = None
     num_samples: int = 1
     max_concurrent_trials: Optional[int] = None
+    search_alg: Optional[SearchAlgo] = None
+    scheduler: Optional[Scheduler] = None
 
 
 class TuneParams(BaseModel):
@@ -170,8 +182,12 @@ class TuneAction(TrainAction):
             entrypoint = _tune
 
         trainable = tune.with_parameters(entrypoint, run=self.run, dataset=input_dataset, checkpoint=checkpoint)
+
         tune_config = self.params['tune_config']
 
+        tune_config['search_alg'] = self.convert_tune_search_alg(tune_config)
+        tune_config['scheduler'] = self.convert_tune_scheduler(tune_config)
+
         hyperparameter = self.params['hyperparameter']
         param_space = self.convert_tune_params(hyperparameter)
         temp_path = tempfile.TemporaryDirectory()
@@ -230,6 +246,91 @@ class TuneAction(TrainAction):
                 **params,
             })
 
+    @staticmethod
+    def convert_tune_scheduler(tune_config):
+        """
+        Convert YAML hyperparameter configuration to a Ray Tune scheduler.
+
+        Args:
+            tune_config (dict): Hyperparameter configuration.
+
+        Returns:
+            object: Ray Tune scheduler instance.
+        """
+
+        from ray.tune.schedulers import (
+            ASHAScheduler,
+            HyperBandScheduler,
+            MedianStoppingRule,
+            PopulationBasedTraining,
+            FIFOScheduler,
+        )
+
+        if tune_config.get('scheduler') is None:
+            return None
+
+        scheduler_map = {
+            'fifo': FIFOScheduler,
+            'asha': ASHAScheduler,
+            'hyperband': HyperBandScheduler,
+            'pbt': PopulationBasedTraining,
+            'median': MedianStoppingRule,
+        }
+
+        scheduler_type = tune_config['scheduler'].get('name', 'fifo').lower()
+        scheduler_class = scheduler_map.get(scheduler_type, ASHAScheduler)
+
+        # 옵션이 있는 경우 전달하고, 없으면 기본 생성자 호출
+        options = tune_config['scheduler'].get('options')
+
+        # options가 None이거나 빈 딕셔너리가 아닌 경우에만 전달
+        scheduler = scheduler_class(**options) if options else scheduler_class()
+
+        return scheduler
+
+    @staticmethod
+    def convert_tune_search_alg(tune_config):
+        """
+        Convert YAML hyperparameter configuration to Ray Tune search algorithm and scheduler.
+
+        Args:
+            tune_config (dict): Hyperparameter configuration.
+
+        Returns:
+            dict: Ray Tune search algorithm and scheduler
+        """
+
+        if tune_config.get('search_alg') is None:
+            return None
+
+        search_alg_name = tune_config['search_alg']['name'].lower()
+        metric = tune_config['metric']
+        mode = tune_config['mode']
+        points_to_evaluate = tune_config['search_alg'].get('points_to_evaluate', None)
+
+        if search_alg_name == 'axsearch':
+            from ray.tune.search.ax import AxSearch
+
+            search_alg = AxSearch(metric=metric, mode=mode)
+        elif search_alg_name == 'bayesoptsearch':
+            from ray.tune.search.bayesopt import BayesOptSearch
+
+            search_alg = BayesOptSearch(metric=metric, mode=mode)
+        elif search_alg_name == 'hyperoptsearch':
+            from ray.tune.search.hyperopt import HyperOptSearch
+
+            search_alg = HyperOptSearch(metric=metric, mode=mode)
+        elif search_alg_name == 'optunasearch':
+            from ray.tune.search.optuna import OptunaSearch
+
+            search_alg = OptunaSearch(metric=metric, mode=mode)
+        elif search_alg_name == 'basicvariantgenerator':
+            from ray.tune.search.basic_variant import BasicVariantGenerator
+
+            search_alg = BasicVariantGenerator(points_to_evaluate=points_to_evaluate)
+
+        return search_alg
+
     @staticmethod
     def convert_tune_params(param_list):
         """
@@ -243,19 +344,31 @@ class TuneAction(TrainAction):
         """
         from ray import tune
 
+        param_handlers = {
+            'uniform': lambda p: tune.uniform(p['min'], p['max']),
+            'quniform': lambda p: tune.quniform(p['min'], p['max']),
+            'loguniform': lambda p: tune.loguniform(p['min'], p['max'], p['base']),
+            'qloguniform': lambda p: tune.qloguniform(p['min'], p['max'], p['base']),
+            'randn': lambda p: tune.randn(p['mean'], p['sd']),
+            'qrandn': lambda p: tune.qrandn(p['mean'], p['sd']),
+            'randint': lambda p: tune.randint(p['min'], p['max']),
+            'qrandint': lambda p: tune.qrandint(p['min'], p['max']),
+            'lograndint': lambda p: tune.lograndint(p['min'], p['max'], p['base']),
+            'qlograndint': lambda p: tune.qlograndint(p['min'], p['max'], p['base']),
+            'choice': lambda p: tune.choice(p['options']),
+            'grid_search': lambda p: tune.grid_search(p['options']),
+        }
+
         param_space = {}
 
         for param in param_list:
             name = param['name']
             param_type = param['type']
 
-            if param_type == 'loguniform':
-                param_space[name] = tune.loguniform(param['min'], param['max'])
-            elif param_type == 'choice':
-                param_space[name] = tune.choice(param['options'])
-            elif param_type == 'randint':
-                param_space[name] = tune.randint(param['min'], param['max'])
-            # Add more type handlers as needed
+            if param_type in param_handlers:
+                param_space[name] = param_handlers[param_type](param)
+            else:
+                raise ValueError(f'Unknown parameter type: {param_type}')
 
         return param_space
 

{synapse_sdk-1.0.0a48 → synapse_sdk-1.0.0a50}/synapse_sdk/plugins/categories/neural_net/templates/config.yaml

@@ -5,7 +5,7 @@ readme: README.md
 description: This is plugin_name plugin
 category: neural_net
 tasks:
-  - object_detection
+  - image.object_detection
 data_type: image
 package_manager: uv
 actions:
@@ -19,6 +19,8 @@ actions:
     hyperparameters:
       ui_schema: |
         Dumped FormKit Schema for hyperparameters
+    options:
+      visualize: false # Whether to visualize the training process
   deployment:
     entrypoint: plugin.inference.MockNetInference
   inference:

synapse_sdk-1.0.0a50/synapse_sdk/plugins/categories/upload/actions/task_pre_annotation.py

@@ -0,0 +1,100 @@
+from enum import Enum
+from typing import Annotated
+
+from pydantic import AfterValidator, BaseModel, field_validator
+from pydantic_core import PydanticCustomError
+
+from synapse_sdk.clients.exceptions import ClientError
+from synapse_sdk.plugins.categories.decorators import register_action
+from synapse_sdk.plugins.enums import PluginCategory, RunMethod
+from synapse_sdk.plugins.models import Run
+from synapse_sdk.utils.pydantic.validators import non_blank
+
+
+class TaskDataAnnotationType(str, Enum):
+    FILE = 'file'
+    INFERENCE = 'inference'
+
+
+class TaskPreAnnotationRun(Run):
+    pass
+
+
+class TaskPreAnnotationParams(BaseModel):
+    """TaskPreAnnotation action parameters.
+
+    Args:
+        name (str): The name of the action.
+        description (str | None): The description of the action.
+        project (int): The project ID.
+        data_collection (int): The data collection ID.
+        task_data_annotation_type (TaskDataAnnotationType): The type of task data annotation.
+    """
+
+    name: Annotated[str, AfterValidator(non_blank)]
+    description: str | None
+    project: int
+    data_collection: int
+    task_data_annotation_type: TaskDataAnnotationType
+
+    @field_validator('data_collection', mode='before')
+    @classmethod
+    def check_data_collection_exists(cls, value: str, info) -> str:
+        """Validate synapse-backend collection exists."""
+        action = info.context['action']
+        client = action.client
+        try:
+            client.get_dataset(value)
+        except ClientError:
+            raise PydanticCustomError('client_error', 'Error occurred while checking data collection exists.')
+        return value
+
+    @field_validator('project', mode='before')
+    @classmethod
+    def check_project_exists(cls, value: str, info) -> str:
+        """Validate synapse-backend project exists."""
+        if not value:
+            return value
+
+        action = info.context['action']
+        client = action.client
+        try:
+            client.get_project(value)
+        except ClientError:
+            raise PydanticCustomError('client_error', 'Error occurred while checking project exists.')
+        return value
+
+
+@register_action
+class TaskPreAnnotationAction(TaskPreAnnotationRun):
+    """TaskPreAnnotation action class.
+
+    * Annotate data to tasks.
+    """
+
+    name = 'task_pre_annotation'
+    category = PluginCategory.UPLOAD
+    method = RunMethod.JOB
+    run_class = TaskPreAnnotationRun
+    progress_categories = {
+        'generate_tasks': {
+            'proportion': 10,
+        },
+        'annotate_task_data': {
+            'proportion': 90,
+        },
+    }
+
+    def start(self):
+        """Start task_pre_annotation action.
+
+        * Generate tasks.
+        * Annotate data to tasks.
+        """
+        task_pre_annotation = self.get_task_pre_annotation()
+        task_pre_annotation.handle_annotate_data_from_files()
+        return {}
+
+    def get_task_pre_annotation(self):
+        """Get task pre annotation entrypoint."""
+        return self.entrypoint()