synapse-sdk 1.0.0a35__py3-none-any.whl → 2025.11.7__py3-none-any.whl

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

@@ -0,0 +1,170 @@
+"""Abstract base classes for ToTask strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Tuple
+
+from synapse_sdk.clients.backend import BackendClient
+
+from ..enums import AnnotationMethod
+from ..models import MetricsRecord
+
+
+class ToTaskContext:
+    """Shared context for ToTask action execution."""
+
+    def __init__(
+        self,
+        params: Dict[str, Any],
+        client: BackendClient,
+        logger: Any,
+        entrypoint: Any = None,
+        config: Optional[Dict[str, Any]] = None,
+        plugin_config: Optional[Dict[str, Any]] = None,
+        job_id: Optional[str] = None,
+        progress_categories: Optional[Dict[str, Any]] = None,
+        metrics_categories: Optional[Dict[str, Any]] = None,
+        project: Optional[Dict[str, Any]] = None,
+        data_collection: Optional[Dict[str, Any]] = None,
+        task_ids: Optional[List[int]] = None,
+        metrics: Optional[MetricsRecord] = None,
+        annotation_method: Optional[AnnotationMethod] = None,
+    ):
+        self.params = params
+        self.client = client
+        self.logger = logger
+        self.entrypoint = entrypoint
+        self.config = config
+        self.plugin_config = plugin_config
+        self.job_id = job_id
+        self.progress_categories = progress_categories
+        self.metrics_categories = metrics_categories
+        self.project = project
+        self.data_collection = data_collection
+        self.task_ids = task_ids or []
+        self.metrics = metrics or MetricsRecord(stand_by=0, failed=0, success=0)
+        self.annotation_method = annotation_method
+        self.temp_files: List[str] = []
+        self.rollback_actions: List[callable] = []
+
+    def add_temp_file(self, file_path: str):
+        """Track temporary files for cleanup."""
+        self.temp_files.append(file_path)
+
+    def add_rollback_action(self, action: callable):
+        """Add rollback action for error recovery."""
+        self.rollback_actions.append(action)
+
+    def update_metrics(self, success_count: int, failed_count: int, total_count: int):
+        """Update execution metrics."""
+        self.metrics = MetricsRecord(
+            stand_by=total_count - success_count - failed_count, failed=failed_count, success=success_count
+        )
+
+
+class ValidationStrategy(ABC):
+    """Abstract base class for validation strategies."""
+
+    @abstractmethod
+    def validate(self, context: ToTaskContext) -> Dict[str, Any]:
+        """Validate specific aspects of the ToTask execution.
+
+        Args:
+            context: Shared context for the action execution
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        pass
+
+
+class AnnotationStrategy(ABC):
+    """Abstract base class for annotation strategies."""
+
+    @abstractmethod
+    def process_task(self, context: ToTaskContext, task_id: int, task_data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        """Process a single task for annotation.
+
+        Args:
+            context: Shared context for the action execution
+            task_id: The task ID to process
+            task_data: The task data dictionary
+            **kwargs: Additional method-specific parameters
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        pass
+
+
+class PreProcessorStrategy(ABC):
+    """Abstract base class for pre-processor management strategies."""
+
+    @abstractmethod
+    def get_preprocessor_info(self, context: ToTaskContext, preprocessor_id: int) -> Dict[str, Any]:
+        """Get pre-processor information.
+
+        Args:
+            context: Shared context for the action execution
+            preprocessor_id: The pre-processor ID
+
+        Returns:
+            Dict with pre-processor info or error
+        """
+        pass
+
+    @abstractmethod
+    def ensure_preprocessor_running(self, context: ToTaskContext, preprocessor_code: str) -> Dict[str, Any]:
+        """Ensure pre-processor is running.
+
+        Args:
+            context: Shared context for the action execution
+            preprocessor_code: The pre-processor code
+
+        Returns:
+            Dict indicating success or failure
+        """
+        pass
+
+
+class DataExtractionStrategy(ABC):
+    """Abstract base class for data extraction strategies."""
+
+    @abstractmethod
+    def extract_data(self, context: ToTaskContext, task_data: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+        """Extract required data from task.
+
+        Args:
+            context: Shared context for the action execution
+            task_data: The task data dictionary
+
+        Returns:
+            Tuple of extracted data values
+        """
+        pass
+
+
+class MetricsStrategy(ABC):
+    """Abstract base class for metrics strategies."""
+
+    @abstractmethod
+    def update_progress(self, context: ToTaskContext, current: int, total: int):
+        """Update progress tracking.
+
+        Args:
+            context: Shared context for the action execution
+            current: Current progress count
+            total: Total items to process
+        """
+        pass
+
+    @abstractmethod
+    def record_task_result(self, context: ToTaskContext, task_id: int, success: bool, error: Optional[str] = None):
+        """Record the result of processing a single task.
+
+        Args:
+            context: Shared context for the action execution
+            task_id: The task ID that was processed
+            success: Whether the task processing was successful
+            error: Error message if unsuccessful
+        """
+        pass

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

@@ -0,0 +1,83 @@
+"""Data extraction strategies for ToTask action."""
+
+from typing import Any, Dict, Optional, Tuple
+
+from .base import DataExtractionStrategy, ToTaskContext
+
+
+class FileUrlExtractionStrategy(DataExtractionStrategy):
+    """Strategy for extracting file URLs from task data."""
+
+    def extract_data(self, context: ToTaskContext, task_data: Dict[str, Any]) -> str | None:
+        """Extract primary file URL from task data.
+
+        Args:
+            context: Shared context for the action execution
+            task_data: The task data dictionary
+
+        Returns:
+            str: The primary file URL or None if not found
+        """
+        try:
+            # This implementation follows the original _extract_primary_file_url logic
+            data_unit = task_data.get('data_unit')
+            if not data_unit:
+                return None
+
+            data_unit_files = data_unit.get('files', {})
+            if not data_unit_files:
+                return None
+
+            # Find primary file URL
+            for key in data_unit_files:
+                if data_unit_files[key]['is_primary']:
+                    return data_unit_files[key]['url']
+
+            return None
+
+        except Exception as e:
+            context.logger.log_message_with_code(
+                context.logger.LogCode.DATA_EXTRACTION_FAILED
+                if hasattr(context.logger, 'LogCode')
+                else 'DATA_EXTRACTION_FAILED',
+                str(e),
+            )
+            return None
+
+
+class InferenceDataExtractionStrategy(DataExtractionStrategy):
+    """Strategy for extracting inference data from task data."""
+
+    def extract_data(self, context: ToTaskContext, task_data: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+        """Extract data needed for inference processing.
+
+        Args:
+            context: Shared context for the action execution
+            task_data: The task data dictionary
+
+        Returns:
+            Tuple of (primary_file_url, inference_metadata)
+        """
+        try:
+            # Reuse the file URL extraction logic
+            file_strategy = FileUrlExtractionStrategy()
+            primary_url = file_strategy.extract_data(context, task_data)
+
+            # Extract additional inference-specific metadata
+            data_unit = task_data.get('data_unit', {})
+            inference_metadata = {
+                'data_unit_id': data_unit.get('id'),
+                'task_id': task_data.get('id'),
+                'additional_params': context.params.get('inference_params', {}),
+            }
+
+            return primary_url, str(inference_metadata) if inference_metadata else None
+
+        except Exception as e:
+            context.logger.log_message_with_code(
+                context.logger.LogCode.DATA_EXTRACTION_FAILED
+                if hasattr(context.logger, 'LogCode')
+                else 'DATA_EXTRACTION_FAILED',
+                str(e),
+            )
+            return None, None

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

@@ -0,0 +1,87 @@
+"""Metrics and progress tracking strategies for ToTask action."""
+
+from typing import Optional
+
+from ..enums import AnnotateTaskDataStatus, LogCode
+from .base import MetricsStrategy, ToTaskContext
+
+
+class ProgressTrackingStrategy(MetricsStrategy):
+    """Strategy for tracking progress and metrics during task processing."""
+
+    def update_progress(self, context: ToTaskContext, current: int, total: int):
+        """Update progress tracking.
+
+        Args:
+            context: Shared context for the action execution
+            current: Current progress count
+            total: Total items to process
+        """
+        try:
+            context.logger.set_progress(current, total, category='annotate_task_data')
+        except Exception as e:
+            context.logger.log_message_with_code(LogCode.PROGRESS_UPDATE_FAILED, str(e))
+
+    def record_task_result(self, context: ToTaskContext, task_id: int, success: bool, error: Optional[str] = None):
+        """Record the result of processing a single task.
+
+        Args:
+            context: Shared context for the action execution
+            task_id: The task ID that was processed
+            success: Whether the task processing was successful
+            error: Error message if unsuccessful
+        """
+        try:
+            if success:
+                status = AnnotateTaskDataStatus.SUCCESS
+                log_data = {'task_id': task_id}
+            else:
+                status = AnnotateTaskDataStatus.FAILED
+                log_data = {'task_id': task_id, 'error': error or 'Unknown error'}
+
+            context.logger.log_annotate_task_data(log_data, status)
+
+        except Exception as e:
+            context.logger.log_message_with_code(LogCode.METRICS_RECORDING_FAILED, str(e))
+
+    def update_metrics(self, context: ToTaskContext, total_tasks: int, success_count: int, failed_count: int):
+        """Update execution metrics.
+
+        Args:
+            context: Shared context for the action execution
+            total_tasks: Total number of tasks
+            success_count: Number of successful tasks
+            failed_count: Number of failed tasks
+        """
+        try:
+            stand_by_count = total_tasks - success_count - failed_count
+            context.update_metrics(success_count, failed_count, total_tasks)
+
+            # Update metrics in the logger
+            metrics_data = {
+                'stand_by': stand_by_count,
+                'failed': failed_count,
+                'success': success_count,
+            }
+            context.logger.log_metrics(metrics_data, 'annotate_task_data')
+
+        except Exception as e:
+            context.logger.log_message_with_code(LogCode.METRICS_UPDATE_FAILED, str(e))
+
+    def finalize_metrics(self, context: ToTaskContext):
+        """Finalize metrics at the end of processing.
+
+        Args:
+            context: Shared context for the action execution
+        """
+        try:
+            metrics = context.metrics
+            total_tasks = len(context.task_ids)
+
+            context.logger.log_message_with_code(LogCode.ANNOTATION_COMPLETED, metrics.success, metrics.failed)
+
+            # Final progress update
+            self.update_progress(context, total_tasks, total_tasks)
+
+        except Exception as e:
+            context.logger.log_message_with_code(LogCode.METRICS_FINALIZATION_FAILED, str(e))

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

@@ -0,0 +1,127 @@
+"""Pre-processor management strategies for ToTask action."""
+
+from typing import Any, Dict
+
+from .base import PreProcessorStrategy, ToTaskContext
+
+
+class PreProcessorManagementStrategy(PreProcessorStrategy):
+    """Strategy for managing pre-processor lifecycle."""
+
+    def get_preprocessor_info(self, context: ToTaskContext, preprocessor_id: int) -> Dict[str, Any]:
+        """Get pre-processor information from the backend.
+
+        Args:
+            context: Shared context for the action execution
+            preprocessor_id: The pre-processor ID
+
+        Returns:
+            Dict with pre-processor info or error
+        """
+        try:
+            client = context.client
+            pre_processor_response = client.get_plugin_release(preprocessor_id)
+            if isinstance(pre_processor_response, str):
+                return {'success': False, 'error': 'Invalid pre-processor response received'}
+
+            pre_processor: Dict[str, Any] = pre_processor_response
+            config = pre_processor.get('config', {})
+            code = config.get('code')
+            version = pre_processor.get('version')
+
+            if not code or not version:
+                return {'success': False, 'error': 'Invalid pre-processor configuration'}
+
+            return {'success': True, 'code': code, 'version': version}
+        except Exception as e:
+            return {'success': False, 'error': f'Failed to get pre-processor info: {str(e)}'}
+
+    def ensure_preprocessor_running(self, context: ToTaskContext, preprocessor_code: str) -> Dict[str, Any]:
+        """Ensure the pre-processor is running, restart if necessary.
+
+        Args:
+            context: Shared context for the action execution
+            preprocessor_code: The pre-processor code
+
+        Returns:
+            Dict indicating success or failure
+        """
+        try:
+            client = context.client
+
+            # Check if pre-processor is running
+            serve_applications_response = client.list_serve_applications(params={'plugin_code': preprocessor_code})
+            if isinstance(serve_applications_response, str):
+                return {'success': False, 'error': 'Invalid serve applications response'}
+
+            # Handle the response properly - it should be a dict with 'results' key
+            if not isinstance(serve_applications_response, dict):
+                return {'success': False, 'error': 'Unexpected serve applications response format'}
+
+            serve_applications: Dict[str, Any] = serve_applications_response
+            results = serve_applications.get('results', [])
+            running_serve_apps = [app for app in results if isinstance(app, dict) and app.get('status') == 'RUNNING']
+
+            # If not running, restart the pre-processor
+            if not running_serve_apps:
+                restart_result = self._restart_preprocessor(context, preprocessor_code)
+                if not restart_result['success']:
+                    return restart_result
+
+                # Verify restart was successful
+                serve_applications_response = client.list_serve_applications(params={'plugin_code': preprocessor_code})
+                if isinstance(serve_applications_response, str):
+                    return {'success': False, 'error': 'Failed to verify pre-processor restart'}
+
+                serve_applications = serve_applications_response
+                results = serve_applications.get('results', [])
+                running_serve_apps = [
+                    app for app in results if isinstance(app, dict) and app.get('status') == 'RUNNING'
+                ]
+
+                if not running_serve_apps:
+                    return {'success': False, 'error': 'Pre-processor failed to start after restart'}
+
+            return {'success': True}
+
+        except Exception as e:
+            return {'success': False, 'error': f'Failed to ensure pre-processor running: {str(e)}'}
+
+    def _restart_preprocessor(self, context: ToTaskContext, preprocessor_code: str) -> Dict[str, Any]:
+        """Restart the pre-processor.
+
+        Args:
+            context: Shared context for the action execution
+            preprocessor_code: The pre-processor code
+
+        Returns:
+            Dict indicating success or failure
+        """
+        try:
+            client = context.client
+
+            # Start the serve application
+            inference_options = context.config.get('inference_options', {})
+            serve_application_deployment_payload = {
+                'agent': context.params.get('agent') if context.params else None,
+                'action': 'deployment',
+                'params': {
+                    'num_cpus': inference_options.get('required_cpu_count', 2),
+                    'num_gpus': inference_options.get('required_gpu_count', 1),
+                },
+                'debug': True,
+            }
+
+            deployment_result = client.run_plugin(
+                preprocessor_code,
+                serve_application_deployment_payload,
+            )
+
+            deployment_job_id = deployment_result.get('job_id')
+            if not deployment_job_id:
+                return {'success': False, 'error': 'No deployment job ID returned'}
+
+            return {'success': True, 'error': 'Pre-processor restarted successfully'}
+
+        except Exception as e:
+            return {'success': False, 'error': f'Failed to restart pre-processor: {str(e)}'}

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

@@ -0,0 +1,143 @@
+"""Validation strategies for ToTask action."""
+
+from typing import Any, Dict
+
+from ..enums import LogCode
+from .base import ToTaskContext, ValidationStrategy
+
+
+class ProjectValidationStrategy(ValidationStrategy):
+    """Strategy for validating project and data collection."""
+
+    def validate(self, context: ToTaskContext) -> Dict[str, Any]:
+        """Validate project and data collection exist and are accessible.
+
+        Args:
+            context: Shared context for the action execution
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        try:
+            client = context.client
+            project_id = context.params['project']
+
+            # Validate project response
+            project_response = client.get_project(project_id)
+            if isinstance(project_response, str):
+                context.logger.log_message_with_code(LogCode.INVALID_PROJECT_RESPONSE)
+                return {'success': False, 'error': 'Invalid project response received'}
+
+            project: Dict[str, Any] = project_response
+            context.project = project
+
+            # Validate data collection exists
+            data_collection_id = project.get('data_collection')
+            if not data_collection_id:
+                context.logger.log_message_with_code(LogCode.NO_DATA_COLLECTION)
+                return {'success': False, 'error': 'Project does not have a data collection'}
+
+            # Validate data collection response
+            data_collection_response = client.get_data_collection(data_collection_id)
+            if isinstance(data_collection_response, str):
+                context.logger.log_message_with_code(LogCode.INVALID_DATA_COLLECTION_RESPONSE)
+                return {'success': False, 'error': 'Invalid data collection response received'}
+
+            data_collection: Dict[str, Any] = data_collection_response
+            context.data_collection = data_collection
+
+            return {'success': True}
+
+        except Exception as e:
+            error_msg = f'Project validation failed: {str(e)}'
+            context.logger.log_message_with_code(LogCode.VALIDATION_FAILED, error_msg)
+            return {'success': False, 'error': error_msg}
+
+
+class TaskValidationStrategy(ValidationStrategy):
+    """Strategy for validating and discovering tasks."""
+
+    def validate(self, context: ToTaskContext) -> Dict[str, Any]:
+        """Discover and validate tasks for processing.
+
+        Args:
+            context: Shared context for the action execution
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        try:
+            client = context.client
+
+            # Build task query parameters
+            task_ids_query_params = {
+                'project': context.params['project'],
+                'fields': 'id',
+            }
+            if context.params.get('task_filters'):
+                task_ids_query_params.update(context.params['task_filters'])
+
+            # Get tasks
+            task_ids_generator, task_ids_count = client.list_tasks(params=task_ids_query_params, list_all=True)
+            task_ids = [
+                int(item.get('id', 0)) for item in task_ids_generator if isinstance(item, dict) and item.get('id')
+            ]
+
+            # Validate tasks found
+            if not task_ids_count:
+                context.logger.log_message_with_code(LogCode.NO_TASKS_FOUND)
+                return {'success': False, 'error': 'No tasks found to annotate'}
+
+            context.task_ids = task_ids
+            return {'success': True, 'task_count': len(task_ids)}
+
+        except Exception as e:
+            error_msg = f'Task validation failed: {str(e)}'
+            context.logger.log_message_with_code(LogCode.VALIDATION_FAILED, error_msg)
+            return {'success': False, 'error': error_msg}
+
+
+class TargetSpecificationValidationStrategy(ValidationStrategy):
+    """Strategy for validating target specification for file annotation."""
+
+    def validate(self, context: ToTaskContext) -> Dict[str, Any]:
+        """Validate target specification exists in file specifications.
+
+        Args:
+            context: Shared context for the action execution
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        try:
+            # Only validate if using FILE annotation method
+            from ..enums import AnnotationMethod
+
+            if context.annotation_method != AnnotationMethod.FILE:
+                return {'success': True}
+
+            target_specification_name = context.params.get('target_specification_name')
+            if not target_specification_name:
+                context.logger.log_message_with_code(LogCode.TARGET_SPEC_REQUIRED)
+                return {'success': False, 'error': 'Target specification name is required for file annotation method'}
+
+            # Check if target specification exists in file specifications
+            if not context.data_collection:
+                return {'success': False, 'error': 'Data collection not available for validation'}
+
+            file_specifications = context.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:
+                context.logger.log_message_with_code(LogCode.TARGET_SPEC_NOT_FOUND, target_specification_name)
+                return {
+                    'success': False,
+                    'error': f"Target specification '{target_specification_name}' not found in file specifications",
+                }
+
+            return {'success': True}
+
+        except Exception as e:
+            error_msg = f'Target specification validation failed: {str(e)}'
+            context.logger.log_message_with_code(LogCode.VALIDATION_FAILED, error_msg)
+            return {'success': False, 'error': error_msg}