synapse-sdk 1.0.0a36__tar.gz → 1.0.0a38__tar.gz

{synapse_sdk-1.0.0a36/synapse_sdk.egg-info → synapse_sdk-1.0.0a38}/PKG-INFO

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

{synapse_sdk-1.0.0a36 → synapse_sdk-1.0.0a38}/synapse_sdk/clients/base.py

@@ -11,6 +11,7 @@ from synapse_sdk.utils.file import files_url_to_path_from_objs
 class BaseClient:
     name = None
     base_url = None
+    page_size = 100
 
     def __init__(self, base_url):
         self.base_url = base_url
@@ -146,7 +147,8 @@ class BaseClient:
         else:
             return response
 
-    def _list_all(self, path, url_conversion=None, params=None, **kwargs):
+    def _list_all(self, path, url_conversion=None, params={}, **kwargs):
+        params['page_size'] = self.page_size
         response = self._get(path, url_conversion, params=params, **kwargs)
         yield from response['results']
         if response['next']:

{synapse_sdk-1.0.0a36 → synapse_sdk-1.0.0a38}/synapse_sdk/plugins/categories/base.py

@@ -133,6 +133,11 @@ class Action:
     def plugin_package_manager(self):
         return self.plugin_config.get('package_manager', 'pip')
 
+    @property
+    def package_manager_options(self):
+        options = {'pip': {}, 'uv': {'uv_pip_install_options': []}}
+        return options[self.plugin_package_manager]
+
     def get_run(self):
         context = {
             'plugin_release': self.plugin_release,
@@ -147,13 +152,16 @@ class Action:
         return {env: os.environ[env] for env in self.REQUIRED_ENVS if env in os.environ}
 
     def get_runtime_env(self):
-        runtime_env = {self.plugin_package_manager: [], 'working_dir': self.plugin_url}
+        runtime_env = {self.plugin_package_manager: {'packages': []}, 'working_dir': self.plugin_url}
 
         if self.requirements:
-            runtime_env[self.plugin_package_manager] += self.requirements
+            runtime_env[self.plugin_package_manager]['packages'] += self.requirements
 
         if self.debug:
-            runtime_env[self.plugin_package_manager] += self.debug_modules
+            runtime_env[self.plugin_package_manager]['packages'] += self.debug_modules
+
+        for key, value in self.package_manager_options.items():
+            runtime_env[self.plugin_package_manager][key] = value
 
         # 맨 마지막에 진행되어야 함
         runtime_env['env_vars'] = self.envs

{synapse_sdk-1.0.0a36 → synapse_sdk-1.0.0a38}/synapse_sdk/plugins/categories/export/actions/export.py

@@ -1,17 +1,77 @@
+import json
 from abc import ABC, abstractmethod
-from typing import Any, Literal
+from datetime import datetime
+from typing import Annotated, Any, Literal
 
-from pydantic import BaseModel, field_validator
+from pydantic import AfterValidator, BaseModel, field_validator
 from pydantic_core import PydanticCustomError
 
 from synapse_sdk.clients.exceptions import ClientError
 from synapse_sdk.i18n import gettext as _
 from synapse_sdk.plugins.categories.base import Action
 from synapse_sdk.plugins.categories.decorators import register_action
+from synapse_sdk.plugins.categories.export.enums import ExportStatus
 from synapse_sdk.plugins.enums import PluginCategory, RunMethod
+from synapse_sdk.plugins.models import Run
+from synapse_sdk.utils.pydantic.validators import non_blank
 from synapse_sdk.utils.storage import get_pathlib
 
 
+class ExportRun(Run):
+    class DataFileLog(BaseModel):
+        """Data file log model."""
+
+        target_id: int
+        data_file_info: str | None
+        status: ExportStatus
+        error: str | None = None
+        created: str
+
+    def log_file(
+        self, log_type: str, target_id: int, data_file_info: dict, status: ExportStatus, error: str | None = None
+    ):
+        """Log export file information.
+
+        Args:
+            log_type (str): The type of log ('export_data_file' or 'export_origin_file').
+            target_id (int): The ID of the data file.
+            data_file_info (dict): The JSON info of the data file.
+            status (ExportStatus): The status of the data file.
+            error (str | None): The error message, if any.
+        """
+        now = datetime.now().isoformat()
+        self.log(
+            log_type,
+            self.DataFileLog(
+                target_id=target_id,
+                data_file_info=json.dumps(data_file_info),
+                status=status.value,
+                error=error,
+                created=now,
+            ).model_dump(),
+        )
+
+    def export_log_json_file(
+        self,
+        target_id: int,
+        data_file_info: dict,
+        status: ExportStatus = ExportStatus.STAND_BY,
+        error: str | None = None,
+    ):
+        """Log export json data file."""
+        self.log_file('export_data_file', target_id, data_file_info, status, error)
+
+    def export_log_original_file(
+        self,
+        target_id: int,
+        data_file_info: dict,
+        status: ExportStatus = ExportStatus.STAND_BY,
+        error: str | None = None,
+    ):
+        """Log export origin data file."""
+        self.log_file('export_origin_file', target_id, data_file_info, status, error)
+
+
 class ExportTargetHandler(ABC):
     """
     Abstract base class for handling export targets.
@@ -153,6 +213,8 @@ class ExportParams(BaseModel):
     Parameters for the export action.
 
     Attributes:
+        name (str): The name of the action.
+        description (str | None): The description of the action.
         storage (int): The storage ID to save the exported data.
         save_original_file (bool): Whether to save the original file.
         path (str): The path to save the exported data.
@@ -160,6 +222,8 @@ class ExportParams(BaseModel):
         filter (dict): The filter criteria to apply.
     """
 
+    name: Annotated[str, AfterValidator(non_blank)]
+    description: str | None = None
     storage: int
     save_original_file: bool = True
     path: str
@@ -193,6 +257,7 @@ class ExportAction(Action):
     category = PluginCategory.EXPORT
     method = RunMethod.JOB
     params_model = ExportParams
+    run_class = ExportRun
     progress_categories = {
         'dataset_conversion': {
             'proportion': 100,

synapse_sdk-1.0.0a38/synapse_sdk/plugins/categories/export/enums.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class ExportStatus(str, Enum):
+    SUCCESS = 'success'
+    FAILED = 'failed'
+    STAND_BY = 'stand_by'

{synapse_sdk-1.0.0a36 → synapse_sdk-1.0.0a38}/synapse_sdk/plugins/categories/export/templates/plugin/export.py

@@ -3,6 +3,8 @@ from pathlib import Path
 
 import requests
 
+from synapse_sdk.plugins.categories.export.enums import ExportStatus
+
 
 def export(run, export_items, path_root, **params):
     """Executes the export task.
@@ -54,12 +56,12 @@ 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(final_data, origin_files_output_path, errors_original_file_list)
+            save_original_file(run, final_data, origin_files_output_path, errors_original_file_list)
 
         # Extract data as JSON files
         if no == 1:
             run.log_message('Saving json file.')
-        save_as_json(final_data, json_output_path, errors_json_file_list)
+        save_as_json(run, final_data, json_output_path, errors_json_file_list)
 
     run.end_log()
 
@@ -100,10 +102,11 @@ def get_original_file_pathlib(files):
     return Path(files['meta']['path_original'])
 
 
-def save_original_file(result, base_path, error_file_list):
+def save_original_file(run, result, base_path, error_file_list):
     """Saves the original file.
 
     Args:
+        run : Execution object
         result (dict): API response data containing file information.
         base_path (Path): The directory where the file will be saved.
         error_file_list (list): A list to store error files.
@@ -111,17 +114,25 @@ def save_original_file(result, base_path, error_file_list):
     file_url = result['files']['url']
     file_name = get_original_file_pathlib(result['files']).name
     response = requests.get(file_url)
+    file_info = {'file_name': file_name}
+    error_msg = ''
     try:
         with (base_path / file_name).open('wb') as file:
             file.write(response.content)
+        status = ExportStatus.SUCCESS
     except Exception as e:
-        error_file_list.append([file_name, str(e)])
+        error_msg = str(e)
+        error_file_list.append([file_name, error_msg])
+        status = ExportStatus.FAILED
+
+    run.export_log_original_file(result['id'], file_info, status, error_msg)
 
 
-def save_as_json(result, base_path, error_file_list):
+def save_as_json(run, result, base_path, error_file_list):
     """Saves the data as a JSON file.
 
     Args:
+        run : Execution object
         result (dict): API response data containing file information.
         base_path (Path): The directory where the file will be saved.
         error_file_list (list): A list to store error files.
@@ -129,8 +140,15 @@ def save_as_json(result, base_path, error_file_list):
     # Default save file name: original file name
     file_name = get_original_file_pathlib(result['files']).stem
     json_data = result['data']
+    file_info = {'file_name': file_name}
+    error_msg = ''
     try:
         with (base_path / f'{file_name}.json').open('w', encoding='utf-8') as f:
             json.dump(json_data, f, indent=4, ensure_ascii=False)
+        status = ExportStatus.SUCCESS
     except Exception as e:
+        error_msg = str(e)
         error_file_list.append([f'{file_name}.json', str(e)])
+        status = ExportStatus.FAILED
+
+    run.export_log_json_file(result['id'], file_info, status, error_msg)

synapse_sdk-1.0.0a38/synapse_sdk/plugins/categories/neural_net/actions/tune.py

@@ -0,0 +1,268 @@
+import copy
+import tempfile
+from pathlib import Path
+from typing import Annotated, Optional
+
+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.categories.neural_net.actions.train import TrainAction, TrainRun
+from synapse_sdk.plugins.enums import PluginCategory, RunMethod
+from synapse_sdk.utils.file import archive
+from synapse_sdk.utils.module_loading import import_string
+from synapse_sdk.utils.pydantic.validators import non_blank
+
+
+class TuneRun(TrainRun):
+    is_tune = True
+    completed_samples = 0
+    num_samples = 0
+    checkpoint_output = None
+
+
+class TuneConfig(BaseModel):
+    mode: Optional[str] = None
+    metric: Optional[str] = None
+    num_samples: int = 1
+    max_concurrent_trials: Optional[int] = None
+
+
+class TuneParams(BaseModel):
+    name: Annotated[str, AfterValidator(non_blank)]
+    description: str
+    checkpoint: int | None
+    dataset: int
+    tune_config: TuneConfig
+
+    @field_validator('name')
+    @staticmethod
+    def unique_name(value, info):
+        action = info.context['action']
+        client = action.client
+        try:
+            job_exists = client.exists(
+                'list_jobs',
+                params={
+                    'ids_ex': action.job_id,
+                    'category': 'neural_net',
+                    'job__action': 'tune',
+                    'is_active': True,
+                    'params': f'name:{value}',
+                },
+            )
+            assert not job_exists, '존재하는 튜닝 작업 이름입니다.'
+        except ClientError:
+            raise PydanticCustomError('client_error', '')
+        return value
+
+
+@register_action
+class TuneAction(TrainAction):
+    """
+    **Must read** Important notes before using Tune:
+
+    1. Path to the model output (which is the return value of your train function)
+       should be set to the checkpoint_output attribute of the run object **before**
+       starting the training.
+    2. Before exiting the training function, report the results to Tune.
+    3. When using own tune.py, take note of the difference in the order of parameters.
+       tune() function starts with hyperparameter, run, dataset, checkpoint, **kwargs
+       whereas the train() function starts with run, dataset, hyperparameter, checkpoint, **kwargs.
+    ----
+    1)
+    Set the output path for the checkpoint to export best model
+
+    output_path = Path('path/to/your/weights')
+    run.checkpoint_output = str(output_path)
+
+    2)
+    Before exiting the training function, report the results to Tune.
+    The results_dict should contain the metrics you want to report.
+
+    Example: (In train function)
+    results_dict = {
+        "accuracy": accuracy,
+        "loss": loss,
+        # Add other metrics as needed
+    }
+    if hasattr(self.dm_run, 'is_tune') and self.dm_run.is_tune:
+        tune.report(results_dict, checkpoint=tune.Checkpoint.from_directory(self.dm_run.checkpoint_output))
+
+
+    3)
+    tune() function takes hyperparameter, run, dataset, checkpoint, **kwargs in that order
+    whereas train() function takes run, dataset, hyperparameter, checkpoint, **kwargs in that order.
+
+    --------------------------------------------------------------------------------------------------------
+
+    **중요** Tune 사용 전 반드시 읽어야 할 사항들
+
+    1. 본 플러그인의 train 함수에서, 학습을 진행하기 코드 전에
+       결과 모델 파일의 경로(train함수의 리턴 값)을 checkpoint_output 속성에 설정해야 합니다.
+    2. 학습이 종료되기 전에, 결과를 Tune에 보고해야 합니다.
+    3. 플러그인에서 tune.py를 직접 생성해서 사용할 시, 매개변수의 순서가 다릅니다.
+
+    ----
+    1)
+    체크포인트를 설정할 경로를 지정합니다.
+    output_path = Path('path/to/your/weights')
+    run.checkpoint_output = str(output_path)
+
+    2)
+    학습이 종료되기 전에, 결과를 Tune에 보고합니다.
+    results_dict = {
+        "accuracy": accuracy,
+        "loss": loss,
+        # 필요한 다른 메트릭 추가
+    }
+    if hasattr(self.dm_run, 'is_tune') and self.dm_run.is_tune:
+        tune.report(results_dict, checkpoint=tune.Checkpoint.from_directory(self.dm_run.checkpoint_output))
+
+    3)
+    tune() 함수는 hyperparameter, run, dataset, checkpoint, **kwargs 순서이고
+    train() 함수는 run, dataset, hyperparameter, checkpoint, **kwargs 순서입니다.
+    """
+
+    name = 'tune'
+    category = PluginCategory.NEURAL_NET
+    method = RunMethod.JOB
+    run_class = TuneRun
+    params_model = TuneParams
+    progress_categories = {
+        'dataset': {
+            'proportion': 5,
+        },
+        'trials': {
+            'proportion': 90,
+        },
+        'model_upload': {
+            'proportion': 5,
+        },
+    }
+
+    def start(self):
+        from ray import tune
+
+        # download dataset
+        self.run.log_message('Preparing dataset for hyperparameter tuning.')
+        input_dataset = self.get_dataset()
+
+        # retrieve checkpoint
+        checkpoint = None
+        if self.params['checkpoint']:
+            self.run.log_message('Retrieving checkpoint.')
+            checkpoint = self.get_model(self.params['checkpoint'])
+
+        # train dataset
+        self.run.log_message('Starting training for hyperparameter tuning.')
+
+        # Save num_samples to TuneRun for logging
+        self.run.num_samples = self.params['tune_config']['num_samples']
+
+        entrypoint = self.entrypoint
+        if not self._tune_override_exists():
+            # entrypoint must be train entrypoint
+            def _tune(param_space, run, dataset, checkpoint=None, **kwargs):
+                return entrypoint(run, dataset, param_space, checkpoint, **kwargs)
+
+            entrypoint = _tune
+
+        trainable = tune.with_parameters(entrypoint, run=self.run, dataset=input_dataset, checkpoint=checkpoint)
+        tune_config = self.params['tune_config']
+
+        hyperparameter = self.params['hyperparameter']
+        param_space = self.convert_tune_params(hyperparameter)
+        temp_path = tempfile.TemporaryDirectory()
+
+        tuner = tune.Tuner(
+            tune.with_resources(trainable, resources=self.tune_resources),
+            tune_config=tune.TuneConfig(**tune_config),
+            run_config=tune.RunConfig(
+                name=f'synapse_tune_hpo_{self.job_id}',
+                log_to_file=('stdout.log', 'stderr.log'),
+                storage_path=temp_path.name,
+            ),
+            param_space=param_space,
+        )
+        result = tuner.fit()
+
+        best_result = result.get_best_result()
+
+        # upload model_data
+        self.run.log_message('Registering best model data.')
+        self.run.set_progress(0, 1, category='model_upload')
+        self.create_model_from_result(best_result)
+        self.run.set_progress(1, 1, category='model_upload')
+
+        self.run.end_log()
+
+        return {'best_result': best_result.config}
+
+    @property
+    def tune_resources(self):
+        resources = {}
+        for option in ['num_cpus', 'num_gpus']:
+            option_value = self.params.get(option)
+            if option_value:
+                # Remove the 'num_' prefix and trailing s from the option name
+                resources[(lambda s: s[4:-1])(option)] = option_value
+        return resources
+
+    def create_model_from_result(self, result):
+        params = copy.deepcopy(self.params)
+        configuration_fields = ['hyperparameter']
+        configuration = {field: params.pop(field) for field in configuration_fields}
+
+        with tempfile.TemporaryDirectory() as temp_path:
+            archive_path = Path(temp_path, 'archive.zip')
+
+            # Archive tune results
+            # https://docs.ray.io/en/latest/tune/tutorials/tune_get_data_in_and_out.html#getting-data-out-of-tune-using-checkpoints-other-artifacts
+            archive(result.path, archive_path)
+
+            return self.client.create_model({
+                'plugin': self.plugin_release.plugin,
+                'version': self.plugin_release.version,
+                'file': str(archive_path),
+                'configuration': configuration,
+                **params,
+            })
+
+    @staticmethod
+    def convert_tune_params(param_list):
+        """
+        Convert YAML hyperparameter configuration to Ray Tune parameter dictionary.
+
+        Args:
+            param_list (list): List of hyperparameter configurations.
+
+        Returns:
+            dict: Ray Tune parameter dictionary
+        """
+        from ray import tune
+
+        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
+
+        return param_space
+
+    @staticmethod
+    def _tune_override_exists(module_path='plugin.tune') -> bool:
+        try:
+            import_string(module_path)
+            return True
+        except ImportError:
+            return False