synapse-sdk 1.0.0a74__py3-none-any.whl → 1.0.0a76__py3-none-any.whl

synapse_sdk/plugins/utils/config.py

@@ -0,0 +1,203 @@
+"""Plugin configuration utilities."""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from synapse_sdk.utils.file import get_dict_from_file
+
+
+def read_plugin_config(plugin_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
+    """Read plugin configuration from config.yaml file.
+
+    Args:
+        plugin_path: Path to plugin directory. If None, looks for config.yaml in current directory.
+
+    Returns:
+        Dict containing plugin configuration.
+
+    Raises:
+        FileNotFoundError: If config.yaml file is not found.
+        ValueError: If config.yaml is invalid.
+    """
+    config_file_name = 'config.yaml'
+    if plugin_path:
+        config_path = Path(plugin_path) / config_file_name
+    else:
+        config_path = config_file_name
+
+    try:
+        return get_dict_from_file(config_path)
+    except FileNotFoundError:
+        raise FileNotFoundError(f'Plugin config file not found: {config_path}')
+    except Exception as e:
+        raise ValueError(f'Invalid plugin config file: {e}')
+
+
+def get_plugin_actions(
+    config: Optional[Dict[str, Any]] = None, plugin_path: Optional[Union[str, Path]] = None
+) -> List[str]:
+    """Get list of action names from plugin configuration.
+
+    Args:
+        config: Plugin configuration dictionary. If None, reads from plugin_path.
+        plugin_path: Path to plugin directory. Used if config is None.
+
+    Returns:
+        List of action names defined in the plugin.
+
+    Raises:
+        ValueError: If neither config nor plugin_path is provided.
+        KeyError: If 'actions' key is missing from config.
+
+    Examples:
+        >>> get_plugin_actions(plugin_path="./my-plugin")
+        ['train', 'inference', 'test']
+
+        >>> config = {'actions': {'train': {...}, 'test': {...}}}
+        >>> get_plugin_actions(config=config)
+        ['train', 'test']
+    """
+    if config is None:
+        if plugin_path is None:
+            raise ValueError('Either config or plugin_path must be provided')
+        config = read_plugin_config(plugin_path)
+
+    if 'actions' not in config:
+        raise KeyError("'actions' key not found in plugin configuration")
+
+    actions = config['actions']
+    if not isinstance(actions, dict):
+        raise ValueError("'actions' must be a dictionary")
+
+    return list(actions.keys())
+
+
+def get_action_config(
+    action_name: str, config: Optional[Dict[str, Any]] = None, plugin_path: Optional[Union[str, Path]] = None
+) -> Dict[str, Any]:
+    """Get configuration for a specific action.
+
+    Args:
+        action_name: Name of the action to get config for.
+        config: Plugin configuration dictionary. If None, reads from plugin_path.
+        plugin_path: Path to plugin directory. Used if config is None.
+
+    Returns:
+        Dictionary containing action configuration.
+
+    Raises:
+        ValueError: If neither config nor plugin_path is provided.
+        KeyError: If action is not found in plugin configuration.
+
+    Examples:
+        >>> get_action_config('train', plugin_path="./my-plugin")
+        {'entrypoint': 'plugin.train.TrainAction', 'method': 'job'}
+    """
+    if config is None:
+        if plugin_path is None:
+            raise ValueError('Either config or plugin_path must be provided')
+        config = read_plugin_config(plugin_path)
+
+    if 'actions' not in config:
+        raise KeyError("'actions' key not found in plugin configuration")
+
+    actions = config['actions']
+    if action_name not in actions:
+        available_actions = list(actions.keys())
+        raise KeyError(f"Action '{action_name}' not found. Available actions: {available_actions}")
+
+    return actions[action_name]
+
+
+def validate_plugin_config(config: Dict[str, Any]) -> bool:
+    """Validate plugin configuration structure.
+
+    Args:
+        config: Plugin configuration dictionary to validate.
+
+    Returns:
+        True if configuration is valid.
+
+    Raises:
+        ValueError: If configuration is invalid with detailed error message.
+
+    Examples:
+        >>> config = {
+        ...     'name': 'My Plugin',
+        ...     'code': 'my-plugin',
+        ...     'version': '1.0.0',
+        ...     'category': 'neural_net',
+        ...     'actions': {'train': {'entrypoint': 'plugin.train.TrainAction'}}
+        ... }
+        >>> validate_plugin_config(config)
+        True
+    """
+    required_fields = ['name', 'code', 'version', 'category', 'actions']
+
+    # Check required fields
+    for field in required_fields:
+        if field not in config:
+            raise ValueError(f"Required field '{field}' missing from plugin configuration")
+
+    # Validate actions structure
+    actions = config['actions']
+    if not isinstance(actions, dict):
+        raise ValueError("'actions' must be a dictionary")
+
+    if not actions:
+        raise ValueError('Plugin must define at least one action')
+
+    # Validate each action
+    for action_name, action_config in actions.items():
+        if not isinstance(action_config, dict):
+            raise ValueError(f"Action '{action_name}' configuration must be a dictionary")
+
+        # Check for entrypoint (required for most actions)
+        if 'entrypoint' not in action_config and action_config.get('method') != 'restapi':
+            raise ValueError(f"Action '{action_name}' missing required 'entrypoint' field")
+
+    # Validate category
+    from synapse_sdk.plugins.enums import PluginCategory
+
+    valid_categories = [cat.value for cat in PluginCategory]
+    if config['category'] not in valid_categories:
+        raise ValueError(f"Invalid category '{config['category']}'. Must be one of: {valid_categories}")
+
+    return True
+
+
+def get_plugin_metadata(
+    config: Optional[Dict[str, Any]] = None, plugin_path: Optional[Union[str, Path]] = None
+) -> Dict[str, Any]:
+    """Get plugin metadata (name, version, description, etc.).
+
+    Args:
+        config: Plugin configuration dictionary. If None, reads from plugin_path.
+        plugin_path: Path to plugin directory. Used if config is None.
+
+    Returns:
+        Dictionary containing plugin metadata.
+
+    Examples:
+        >>> get_plugin_metadata(plugin_path="./my-plugin")
+        {
+            'name': 'My Plugin',
+            'code': 'my-plugin',
+            'version': '1.0.0',
+            'category': 'neural_net',
+            'description': 'A custom ML plugin'
+        }
+    """
+    if config is None:
+        if plugin_path is None:
+            raise ValueError('Either config or plugin_path must be provided')
+        config = read_plugin_config(plugin_path)
+
+    metadata_fields = ['name', 'code', 'version', 'category', 'description']
+    metadata = {}
+
+    for field in metadata_fields:
+        if field in config:
+            metadata[field] = config[field]
+
+    return metadata

synapse_sdk/plugins/utils/legacy.py

@@ -0,0 +1,95 @@
+"""Legacy utility functions for backward compatibility."""
+
+from pathlib import Path
+
+from synapse_sdk.i18n import gettext as _
+from synapse_sdk.plugins.exceptions import ActionError
+
+from .actions import get_action
+
+
+def read_requirements(file_path):
+    """Read and parse a requirements.txt file.
+
+    Args:
+        file_path: Path to the requirements.txt file
+
+    Returns:
+        List of requirement strings, or None if file doesn't exist
+    """
+    file_path = Path(file_path)
+    if not file_path.exists():
+        return None
+
+    requirements = []
+    for line in file_path.read_text().splitlines():
+        stripped_line = line.strip()
+        if stripped_line and not stripped_line.startswith('#'):
+            requirements.append(stripped_line)
+    return requirements
+
+
+def run_plugin(
+    action,
+    params,
+    plugin_config=None,
+    plugin_path=None,
+    modules=None,
+    requirements=None,
+    envs=None,
+    debug=False,
+    **kwargs,
+):
+    """Execute a plugin action with the specified parameters.
+
+    Args:
+        action: The action name to execute
+        params: Parameters for the action
+        plugin_config: Plugin configuration dictionary
+        plugin_path: Path to the plugin directory
+        modules: List of modules for debugging
+        requirements: List of requirements
+        envs: Environment variables dictionary
+        debug: Whether to run in debug mode
+        **kwargs: Additional keyword arguments
+
+    Returns:
+        Result of the action execution
+    """
+    from synapse_sdk.plugins.models import PluginRelease
+
+    if not envs:
+        envs = {}
+
+    if debug:
+        if plugin_path and plugin_path.startswith('http'):
+            if not plugin_config:
+                raise ActionError({'config': _('"plugin_path"가 url인 경우에는 "config"가 필수입니다.')})
+            plugin_release = PluginRelease(config=plugin_config)
+        else:
+            plugin_release = PluginRelease(plugin_path=plugin_path)
+            plugin_config = plugin_release.config
+
+        if action not in plugin_release.actions:
+            raise ActionError({'action': _('해당 액션은 존재하지 않습니다.')})
+
+        if plugin_path:
+            envs['SYNAPSE_DEBUG_PLUGIN_PATH'] = plugin_path
+
+        if modules:
+            envs['SYNAPSE_DEBUG_MODULES'] = ','.join(modules)
+
+    else:
+        if plugin_config is None:
+            raise ActionError({'config': _('플러그인 설정은 필수입니다.')})
+
+    action = get_action(
+        action,
+        params,
+        config=plugin_config,
+        requirements=requirements,
+        envs=envs,
+        debug=debug,
+        **kwargs,
+    )
+    return action.run_action()

synapse_sdk/plugins/utils/registry.py

@@ -0,0 +1,58 @@
+"""Plugin registry utilities."""
+
+from typing import List
+
+from synapse_sdk.plugins.enums import PluginCategory
+
+
+def get_plugin_categories() -> List[str]:
+    """Get list of all available plugin categories.
+
+    Returns:
+        List of plugin category names.
+
+    Examples:
+        >>> get_plugin_categories()
+        ['neural_net', 'export', 'upload', 'smart_tool', 'post_annotation', 'pre_annotation', 'data_validation']
+    """
+    return [plugin_category.value for plugin_category in PluginCategory]
+
+
+def is_valid_category(category: str) -> bool:
+    """Check if a category is valid.
+
+    Args:
+        category: Category name to validate.
+
+    Returns:
+        True if category is valid, False otherwise.
+
+    Examples:
+        >>> is_valid_category('neural_net')
+        True
+        >>> is_valid_category('invalid_category')
+        False
+    """
+    return category in get_plugin_categories()
+
+
+def get_category_display_name(category: str) -> str:
+    """Get human-readable display name for a category.
+
+    Args:
+        category: Category name.
+
+    Returns:
+        Human-readable category name.
+
+    Examples:
+        >>> get_category_display_name('neural_net')
+        'Neural Net'
+        >>> get_category_display_name('data_validation')
+        'Data Validation'
+    """
+    try:
+        plugin_category = PluginCategory(category)
+        return plugin_category.name.replace('_', ' ').title()
+    except ValueError:
+        return category.replace('_', ' ').title()

synapse_sdk/plugins/utils.py

@@ -43,7 +43,34 @@ def get_plugin_categories():
     return [plugin_category.value for plugin_category in PluginCategory]
 
 
+def get_plugin_actions(config=None, plugin_path=None):
+    """Get list of action names from plugin configuration.
+
+    Args:
+        config: Plugin configuration dictionary. If None, reads from plugin_path.
+        plugin_path: Path to plugin directory. Used if config is None.
+
+    Returns:
+        List of action names defined in the plugin.
+    """
+    if config is None:
+        if plugin_path is None:
+            config = read_plugin_config()
+        else:
+            config = read_plugin_config(plugin_path)
+
+    if 'actions' not in config:
+        raise KeyError("'actions' key not found in plugin configuration")
+
+    actions = config['actions']
+    if not isinstance(actions, dict):
+        raise ValueError("'actions' must be a dictionary")
+
+    return list(actions.keys())
+
+
 def read_plugin_config(plugin_path=None):
+    """Legacy function for backward compatibility."""
     config_file_name = 'config.yaml'
     if plugin_path:
         config_path = Path(plugin_path) / config_file_name

synapse_sdk/shared/enums.py

@@ -6,3 +6,4 @@ class Context(str, Enum):
     SUCCESS = 'success'
     WARNING = 'warning'
     DANGER = 'danger'
+    ERROR = 'error'

synapse_sdk/utils/converters/__init__.py

@@ -192,7 +192,9 @@ class ToDMConverter(BaseConverter):
                     json_filename = os.path.splitext(img_filename)[0] + '.json'
                     with open(os.path.join(json_dir, json_filename), 'w', encoding='utf-8') as jf:
                         json.dump(dm_json, jf, indent=2, ensure_ascii=False)
-                    if img_src_path and os.path.exists(img_src_path):
+                    if img_src_path:
+                        if not os.path.exists(img_src_path):
+                            raise FileNotFoundError(f'Source file does not exist: {img_src_path}')
                         shutil.copy(img_src_path, os.path.join(original_file_dir, img_filename))
         else:
             json_dir = os.path.join(output_dir, 'json')

synapse_sdk/utils/converters/dm/__init__.py

@@ -0,0 +1,109 @@
+from abc import ABC, abstractmethod
+
+
+class BaseDMConverter(ABC):
+    """Base class for DM format converters."""
+
+    SUPPORTED_TOOLS = [
+        'bounding_box',
+        'named_entity',
+        'classification',
+        'polyline',
+        'keypoint',
+        '3d_bounding_box',
+        'segmentation',
+        'polygon',
+        'relation',
+        'group',
+    ]
+
+    def __init__(self):
+        """Initialize the base converter."""
+        self.tool_processors = self._setup_tool_processors()
+
+    def _setup_tool_processors(self):
+        """Setup tool processor mapping."""
+        return {
+            'bounding_box': self._process_bounding_box,
+            'named_entity': self._process_named_entity,
+            'classification': self._process_classification,
+            'polyline': self._process_polyline,
+            'keypoint': self._process_keypoint,
+            '3d_bounding_box': self._process_3d_bounding_box,
+            'segmentation': self._process_segmentation,
+            'polygon': self._process_polygon,
+            'relation': self._process_relation,
+            'group': self._process_group,
+        }
+
+    @abstractmethod
+    def convert(self):
+        """Convert data from one format to another."""
+        pass
+
+    @abstractmethod
+    def _process_bounding_box(self, *args, **kwargs):
+        """Process bounding box annotation."""
+        pass
+
+    @abstractmethod
+    def _process_named_entity(self, *args, **kwargs):
+        """Process named entity annotation."""
+        pass
+
+    @abstractmethod
+    def _process_classification(self, *args, **kwargs):
+        """Process classification annotation."""
+        pass
+
+    @abstractmethod
+    def _process_polyline(self, *args, **kwargs):
+        """Process polyline annotation."""
+        pass
+
+    @abstractmethod
+    def _process_keypoint(self, *args, **kwargs):
+        """Process keypoint annotation."""
+        pass
+
+    @abstractmethod
+    def _process_3d_bounding_box(self, *args, **kwargs):
+        """Process 3D bounding box annotation."""
+        pass
+
+    @abstractmethod
+    def _process_segmentation(self, *args, **kwargs):
+        """Process segmentation annotation."""
+        pass
+
+    @abstractmethod
+    def _process_polygon(self, *args, **kwargs):
+        """Process polygon annotation."""
+        pass
+
+    @abstractmethod
+    def _process_relation(self, *args, **kwargs):
+        """Process relation annotation."""
+        pass
+
+    @abstractmethod
+    def _process_group(self, *args, **kwargs):
+        """Process group annotation."""
+        pass
+
+    def _handle_unknown_tool(self, tool_type, item_id=None):
+        """Handle unknown tool types with consistent warning message."""
+        warning_msg = f"Warning: Unknown tool type '{tool_type}'"
+        if item_id:
+            warning_msg += f' for item {item_id}'
+        print(warning_msg)
+
+    def _extract_media_type_info(self, media_id):
+        """Extract media type information from media ID."""
+        media_type = media_id.split('_')[0] if '_' in media_id else media_id
+        media_type_plural = media_type + 's' if not media_type.endswith('s') else media_type
+        return media_type, media_type_plural
+
+    def _singularize_media_type(self, media_type_plural):
+        """Convert plural media type to singular."""
+        return media_type_plural.rstrip('s')