synapse-sdk 1.0.0a59__py3-none-any.whl → 1.0.0a61__py3-none-any.whl

synapse_sdk/devtools/web/vite.config.js

@@ -0,0 +1,13 @@
+import { defineConfig } from "vite";
+import tailwindcss from "@tailwindcss/vite";
+import solidPlugin from "vite-plugin-solid";
+
+export default defineConfig({
+  plugins: [tailwindcss(), solidPlugin()],
+  server: {
+    port: 3000,
+  },
+  build: {
+    target: "esnext",
+  },
+});

synapse_sdk/plugins/categories/neural_net/actions/tune.py

@@ -260,10 +260,10 @@ class TuneAction(TrainAction):
 
         from ray.tune.schedulers import (
             ASHAScheduler,
+            FIFOScheduler,
             HyperBandScheduler,
             MedianStoppingRule,
             PopulationBasedTraining,
-            FIFOScheduler,
         )
 
         if tune_config.get('scheduler') is None:

synapse_sdk/plugins/categories/neural_net/templates/config.yaml

@@ -13,12 +13,24 @@ actions:
     dataset: dataset
     entrypoint: plugin.train.train
     metrics:
-      epoch:
-        - loss
-        - miou
+      train:
+        epoch:  
+          loss:  # Use the plugin's internal variable as the key, and the user-facing title in name.
+            name: Loss
+      validation:
+        epoch:
+          acc:
+            name: Accuracy
     hyperparameters:
       ui_schema: |
         Dumped FormKit Schema for hyperparameters
+    visualizations:
+      validation_samples_per_epochs:   # put in log_visualization name
+        type: vis_type
+        name: user-facing title
+        options:
+          group_name: Epoch
+          thumbnail_size: [50, 50]
     options:
       visualize: false # Whether to visualize the training process
   deployment:

synapse_sdk/plugins/categories/neural_net/templates/plugin/inference.py

@@ -1,14 +1,30 @@
-from ray import serve
+from pydantic import BaseModel
 
+# for load file with synapse
+# from synapse_sdk.types import FileField
+from synapse_sdk.plugins.categories.neural_net.base.inference import BaseInference, app
 
-class MockNetInference:
-    model_id = None
 
-    @serve.multiplexed()
-    async def get_model(self, model_id: str):
-        return model_id
+class InputData(BaseModel):  # Pydantic
+    input_string: str
 
-    async def __call__(self):
-        model_id = await self.get_model(serve.get_multiplexed_model_id())
-        message = 'hello datamaker!!!'
-        return {'model_id': model_id, 'message': message}
+
+class ResNetInference(BaseInference):
+    async def _get_model(self, model):  # Load model
+        model_directory_path = model['path']
+
+        # implement model_load code
+        model = model_directory_path
+
+        return model  # return loaded_model
+
+    @app.post('/load_model')
+    async def load_model(self):
+        await self.get_model()
+
+    @app.post('/')
+    async def infer(self, data: InputData):
+        model = await self.get_model()
+        results = model(data.input_string)  # This is Sample code. implement your model's prediction code
+
+        return results

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

@@ -1,12 +1,13 @@
 import json
 from datetime import datetime
 from enum import Enum
-from typing import Annotated
+from typing import Annotated, Any, Dict, List, Optional
 
 import requests
 from pydantic import AfterValidator, BaseModel, field_validator
 from pydantic_core import PydanticCustomError
 
+from synapse_sdk.clients.backend import BackendClient
 from synapse_sdk.clients.exceptions import ClientError
 from synapse_sdk.plugins.categories.base import Action
 from synapse_sdk.plugins.categories.decorators import register_action
@@ -29,7 +30,7 @@ class ToTaskRun(Run):
     class AnnotateTaskDataLog(BaseModel):
         """Log model for annotate task data."""
 
-        task_info: str | None
+        task_info: Optional[str] = None
         status: AnnotateTaskDataStatus
         created: str
 
@@ -40,7 +41,7 @@ class ToTaskRun(Run):
         failed: int
         success: int
 
-    def log_annotate_task_data(self, task_info: dict, status: AnnotateTaskDataStatus):
+    def log_annotate_task_data(self, task_info: Dict[str, Any], status: AnnotateTaskDataStatus):
         """Log annotate task data."""
         now = datetime.now().isoformat()
         self.log(
@@ -56,7 +57,7 @@ class ToTaskRun(Run):
             category (str): The category of the metrics.
         """
         record = self.MetricsRecord.model_validate(record)
-        self.set_metrics(value=record.dict(), category=category)
+        self.set_metrics(value=record.model_dump(), category=category)
 
 
 class ToTaskParams(BaseModel):
@@ -66,7 +67,7 @@ class ToTaskParams(BaseModel):
         name (str): The name of the action.
         description (str | None): The description of the action.
         project (int): The project ID.
-        task_filter (dict): The filter of tasks.
+        task_filters (dict): The filters of tasks.
         method (AnnotationMethod): The method of annotation.
         target_specification_name (str | None): The name of the target specification.
         pre_processor (int | None): The pre processor ID.
@@ -74,17 +75,17 @@ class ToTaskParams(BaseModel):
     """
 
     name: Annotated[str, AfterValidator(non_blank)]
-    description: str | None = None
+    description: Optional[str] = None
     project: int
-    task_filter: dict
-    method: AnnotationMethod | None = None
-    target_specification_name: str | None = None
-    pre_processor: int | None = None
-    pre_processor_params: dict
+    task_filters: Dict[str, Any]
+    method: Optional[AnnotationMethod] = None
+    target_specification_name: Optional[str] = None
+    pre_processor: Optional[int] = None
+    pre_processor_params: Dict[str, Any]
 
     @field_validator('project', mode='before')
     @classmethod
-    def check_project_exists(cls, value: str, info) -> str:
+    def check_project_exists(cls, value: int, info) -> int:
         """Validate synapse-backend project exists."""
         if not value:
             return value
@@ -100,15 +101,42 @@ class ToTaskParams(BaseModel):
 
 @register_action
 class ToTaskAction(Action):
-    """ToTask action class.
-
-    * Annotate data to tasks.
+    """ToTask action for pre-annotation data processing.
+
+    This action handles the process of annotating data to tasks in a project. It supports
+    two annotation methods: file-based annotation and inference-based annotation.
+
+    File-based annotation fetches data from file URLs specified in task data units,
+    downloads and processes JSON data, and updates task data with the processed information.
+    It also validates target specification names against file specifications.
+
+    Inference-based annotation is currently not supported but will support model inference
+    for automatic data annotation in future implementations.
+
+    Attrs:
+        name (str): Action name, set to 'to_task'.
+        category (PluginCategory): Plugin category, set to PRE_ANNOTATION.
+        method (RunMethod): Execution method, set to JOB.
+        run_class (Type[ToTaskRun]): Run class for this action.
+        params_model (Type[ToTaskParams]): Parameter validation model.
+        progress_categories (Dict): Progress tracking configuration.
+        metrics_categories (Set[str]): Metrics categories for this action.
+
+    Note:
+        This action requires a valid project with an associated data collection.
+        For file-based annotation, the target_specification_name must exist in the
+        project's file specifications.
+
+    Raises:
+        ValueError: If run instance or parameters are not properly initialized.
+        ClientError: If there are issues with backend API calls.
     """
 
     name = 'to_task'
     category = PluginCategory.PRE_ANNOTATION
     method = RunMethod.JOB
     run_class = ToTaskRun
+    params_model = ToTaskParams
     progress_categories = {
         'annotate_task_data': {
             'proportion': 100,
@@ -117,94 +145,238 @@ class ToTaskAction(Action):
     metrics_categories = {'annotate_task_data'}
 
     def start(self):
-        """Start file_to_task action.
+        """Start to_task action.
 
         * Generate tasks.
         * Annotate data to tasks.
         """
+        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)
+        assert isinstance(self.run.client, BackendClient)
+
+        client: BackendClient = self.run.client
+        project_id = self.params['project']
+        project_response = client.get_project(project_id)
+        if isinstance(project_response, str):
+            self.run.log_message('Invalid project response received.')
+            self.run.end_log()
+            return {}
+        project: Dict[str, Any] = project_response
+
+        data_collection_id = project.get('data_collection')
+        if not data_collection_id:
+            self.run.log_message('Project does not have a data collection.')
+            self.run.end_log()
+            return {}
 
-        # entrypoint = self.entrypoint(self.run)
-        client = self.run.client
-        # project_id = self.params['project']
-        # project = client.get_project(project_id)
-        # data_collection_id = project['dataset']
-        # data_collection = client.get_dataset(data_collection_id)
+        data_collection_response = client.get_data_collection(data_collection_id)
+        if isinstance(data_collection_response, str):
+            self.run.log_message('Invalid data collection response received.')
+            self.run.end_log()
+            return {}
+        data_collection: Dict[str, Any] = data_collection_response
 
         # Generate tasks if provided project is empty.
         task_ids_query_params = {
             'project': self.params['project'],
             'fields': 'id',
         }
-        if self.params.get('task_filter'):
-            task_ids_query_params.update(self.params['task_filter'])
+        if self.params['task_filters']:
+            task_ids_query_params.update(self.params['task_filters'])
         task_ids_generator, task_ids_count = client.list_tasks(params=task_ids_query_params, list_all=True)
-        task_ids = [item['id'] for item in task_ids_generator]
+        task_ids = [int(item.get('id', 0)) for item in task_ids_generator if isinstance(item, dict) and item.get('id')]
 
         # If no tasks found, break the job.
         if not task_ids_count:
             self.run.log_message('Tasks to annotate not found.')
             self.run.end_log()
+            return {}
 
         # Annotate data to tasks.
-        task_data_annotation_type = self.params['task_data_annotation_type']
-        if task_data_annotation_type == AnnotationMethod.FILE:
-            self._handle_annotate_data_from_files(task_ids)
-        elif task_data_annotation_type == AnnotationMethod.INFERENCE:
+        method = self.params.get('method')
+        if method == AnnotationMethod.FILE:
+            # Check if target specification name exists in file specifications.
+            target_specification_name = self.params.get('target_specification_name')
+            if not target_specification_name:
+                self.run.log_message('Target specification name is required for file annotation method.')
+                self.run.end_log()
+                return {}
+
+            file_specifications = data_collection.get('file_specifications', [])
+            target_spec_exists = any(spec.get('name') == target_specification_name for spec in file_specifications)
+            if not target_spec_exists:
+                self.run.log_message(
+                    f'Target specification name "{target_specification_name}" not found in file specifications'
+                )
+                self.run.end_log()
+                return {}
+            self._handle_annotate_data_from_files(task_ids, target_specification_name)
+        elif method == AnnotationMethod.INFERENCE:
             self._handle_annotate_data_with_inference(task_ids)
+        else:
+            self.run.log_message(f'Unsupported annotation method: {method}')
+            self.run.end_log()
+            return {}
 
         return {}
 
-    def _handle_annotate_data_from_files(self, task_ids: list[int]):
+    def _handle_annotate_data_from_files(self, task_ids: List[int], target_specification_name: str):
         """Handle annotate data from files to tasks.
 
         Args:
-            task_ids (list[int]): List of task IDs to annotate data to.
+            task_ids (List[int]): List of task IDs to annotate data to.
+            target_specification_name (str): The name of the target specification.
         """
-        client = self.run.client
-        if not (target_task_data_specification_code := self.params.get('target_task_data_specification_code')):
-            self.run.log_message('Target task data specification code not found.')
-            self.run.end_log()
+        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)
+        assert isinstance(self.run.client, BackendClient)
+
+        client: BackendClient = self.run.client
         task_params = {
             'fields': 'id,data,data_unit',
             'expand': 'data_unit',
         }
-        for task_id in task_ids:
-            task = client.get_task(task_id, params=task_params)
-            data_file = task['data_unit']['files'].get(target_task_data_specification_code)
-            if not data_file:
-                self.run.log_message(f'File specification not found for task {task_id}')
-                self.run.log_annotate_task_data(
-                    {'task_id': task_id, 'error': 'File specification not found'}, AnnotateTaskDataStatus.FAILED
-                )
-                continue
-            url = data_file.get('url')
-            if not url:
-                self.run.log_message(f'URL not found for task {task_id}')
-                self.run.log_annotate_task_data(
-                    {'task_id': task_id, 'error': 'URL not found'}, AnnotateTaskDataStatus.FAILED
-                )
-                continue
 
+        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...')
+
+        # Process each task
+        for task_id in task_ids:
             try:
-                response = requests.get(url)
-                response.raise_for_status()  # Raise an exception for 4XX/5XX responses
-                data = json.loads(response.content)
-                client.patch_task(task_id, data={'data': data})
+                result = self._process_single_task(client, task_id, task_params, target_specification_name)
+                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')
 
-                # Log success
-                self.run.log_annotate_task_data({'task_id': task_id, 'url': url}, AnnotateTaskDataStatus.SUCCESS)
             except Exception as e:
-                self.run.log_message(f'Failed to get content from URL for task {task_id}: {str(e)}')
-                self.run.log_annotate_task_data(
-                    {'task_id': task_id, 'url': url, 'error': str(e)}, AnnotateTaskDataStatus.FAILED
-                )
-                continue
+                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'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
+    ) -> Dict[str, Any]:
+        """Process a single task for annotation.
+
+        Args:
+            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.
+
+        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)
+
+        # Get task data
+        task_response = client.get_task(task_id, params=task_params)
+        if isinstance(task_response, str):
+            error_msg = 'Invalid task response'
+            self.run.log_message(f'{error_msg} received 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}
+
+        task: Dict[str, Any] = task_response
+
+        # Extract data file information
+        data_unit = task.get('data_unit', {})
+        files = data_unit.get('files', {})
+        data_file = files.get(target_specification_name)
+
+        if not data_file:
+            error_msg = 'File specification not found'
+            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}
+
+        url = data_file.get('url')
+        if not url:
+            error_msg = 'URL not found'
+            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}
+
+        # Fetch and process the data
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            data = json.loads(response.content)
+
+            # Submit annotation data
+            client.annotate_task_data(task_id, data={'action': 'submit', 'data': data})
+
+            # Log success
+            self.run.log_annotate_task_data({'task_id': task_id, 'url': url}, AnnotateTaskDataStatus.SUCCESS)
+            return {'success': True}
+
+        except requests.RequestException as e:
+            error_msg = f'Failed to fetch data from URL: {str(e)}'
+            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}
+        except json.JSONDecodeError as e:
+            error_msg = f'Failed to parse JSON data: {str(e)}'
+            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 _update_metrics(self, total_tasks: int, success_count: int, failed_count: int):
+        """Update metrics for task annotation progress.
 
-    def _handle_annotate_data_with_inference(self, task_ids: list[int]):
+        Args:
+            total_tasks (int): Total number of tasks to process.
+            success_count (int): Number of successfully processed tasks.
+            failed_count (int): Number of failed tasks.
+        """
+        if not self.run:
+            raise ValueError('Run instance not properly initialized')
+
+        # Type assertion to help the linter
+        assert isinstance(self.run, ToTaskRun)
+
+        metrics = self.run.MetricsRecord(
+            stand_by=total_tasks - success_count - failed_count, failed=failed_count, success=success_count
+        )
+        self.run.log_metrics(metrics, 'annotate_task_data')
+
+    def _handle_annotate_data_with_inference(self, task_ids: List[int]):
         """Handle annotate data with inference to tasks.
 
         Args:
-            task_ids (list[int]): List of task IDs to annotate data to.
+            task_ids (List[int]): List of task IDs to annotate data to.
         """
+        if not self.run:
+            raise ValueError('Run instance not properly initialized')
+
         self.run.log_message('Pre annotation with inference is not supported.')
         self.run.end_log()

synapse_sdk/plugins/categories/pre_annotation/templates/config.yaml

@@ -3,5 +3,17 @@ actions:
     entrypoint: plugin.pre_annotation.pre_annotate
   to_task:
     entrypoint: plugin.to_task.AnnotationToTask
-    ui_schema: |
-      Dumped FormKit Schema for pre_annotation plugin to_task action's custom options
+    ui_schema:
+      - $formkit: "radio"
+        name: "schema_to_convert"
+        label: "변환 스키마"
+        help: "변환 스키마 선택"
+        required: True
+        value: "<yolo>"
+        option:
+          - label: "Yolo"
+            value: "yolo"
+          - label: "Coco"
+            value: "coco"
+          - label: "Pascal"
+            value: "pascal"