synapse-sdk 2025.9.5__py3-none-any.whl → 2025.10.6__py3-none-any.whl

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

@@ -0,0 +1,284 @@
+"""Annotation strategies for ToTask action."""
+
+from typing import Any, Dict
+
+from ..enums import AnnotateTaskDataStatus, LogCode
+from .base import AnnotationStrategy, ToTaskContext
+
+
+class FileAnnotationStrategy(AnnotationStrategy):
+    """Strategy for file-based annotation processing."""
+
+    def process_task(
+        self, context: ToTaskContext, task_id: int, task_data: Dict[str, Any], target_specification_name: str, **kwargs
+    ) -> Dict[str, Any]:
+        """Process a single task for file-based annotation.
+
+        Args:
+            context: Shared context for the action execution
+            task_id: The task ID to process
+            task_data: The task data dictionary
+            target_specification_name: The name of the target specification
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        try:
+            client = context.client
+            logger = context.logger
+
+            # Get data unit
+            data_unit = task_data.get('data_unit')
+            if not data_unit:
+                error_msg = 'Task does not have a data unit'
+                logger.log_annotate_task_event(LogCode.NO_DATA_UNIT, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Get data unit files
+            data_unit_files = data_unit.get('files', {})
+            if not data_unit_files:
+                error_msg = 'Data unit does not have files'
+                logger.log_annotate_task_event(LogCode.NO_DATA_UNIT_FILES, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Extract primary file URL from task data
+            primary_file_url, primary_file_original_name = self._extract_primary_file_url(task_data)
+            if not primary_file_url:
+                error_msg = 'Primary image URL not found in task data'
+                logger.log_annotate_task_event(LogCode.PRIMARY_IMAGE_URL_NOT_FOUND, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Get target specification file
+            target_file = data_unit_files.get(target_specification_name)
+            if not target_file:
+                error_msg = 'File specification not found'
+                logger.log_annotate_task_event(LogCode.FILE_SPEC_NOT_FOUND, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Get target file details
+            target_file_url = target_file.get('url')
+            target_file_original_name = target_file.get('file_name_original')
+
+            if not target_file_original_name:
+                error_msg = 'File original name not found'
+                logger.log_annotate_task_event(LogCode.FILE_ORIGINAL_NAME_NOT_FOUND, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            if not target_file_url:
+                error_msg = 'URL not found'
+                logger.log_annotate_task_event(LogCode.URL_NOT_FOUND, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Fetch and process the data using template
+            try:
+                # Convert data to task object using action's entrypoint
+                annotation_to_task = context.entrypoint(logger)
+                converted_data = annotation_to_task.convert_data_from_file(
+                    primary_file_url, primary_file_original_name, target_file_url, target_file_original_name
+                )
+            except Exception as e:
+                if 'requests' in str(type(e)):
+                    error_msg = f'Failed to fetch data from URL: {str(e)}'
+                    logger.log_annotate_task_event(LogCode.FETCH_DATA_FAILED, target_file_url, task_id)
+                else:
+                    error_msg = f'Failed to convert data to task object: {str(e)}'
+                    logger.log_annotate_task_event(LogCode.CONVERT_DATA_FAILED, str(e), task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Submit annotation data
+            try:
+                client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_data})
+                logger.log_annotate_task_data(
+                    {'task_id': task_id, 'target_spec': target_specification_name}, AnnotateTaskDataStatus.SUCCESS
+                )
+                return {'success': True}
+            except Exception as e:
+                error_msg = f'Failed to submit annotation data: {str(e)}'
+                logger.log_annotate_task_event(LogCode.ANNOTATION_SUBMISSION_FAILED, task_id, str(e))
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+        except Exception as e:
+            error_msg = f'Failed to process file annotation for task {task_id}: {str(e)}'
+            context.logger.log_annotate_task_event(LogCode.TASK_PROCESSING_FAILED, task_id, str(e))
+            context.logger.log_annotate_task_data(
+                {'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED
+            )
+            return {'success': False, 'error': error_msg}
+
+    def _extract_primary_file_url(self, task_data: Dict[str, Any]) -> tuple:
+        """Extract the primary file URL from task data.
+
+        Args:
+            task_data: The task data dictionary
+
+        Returns:
+            Tuple of (primary_file_url, primary_file_original_name)
+        """
+        data_unit = task_data.get('data_unit', {})
+        files = data_unit.get('files', {})
+
+        for file_info in files.values():
+            if isinstance(file_info, dict) and file_info.get('is_primary') and file_info.get('url'):
+                return file_info['url'], file_info.get('file_name_original')
+
+        return None, None
+
+
+class InferenceAnnotationStrategy(AnnotationStrategy):
+    """Strategy for inference-based annotation processing."""
+
+    def process_task(self, context: ToTaskContext, task_id: int, task_data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        """Process a single task for inference-based annotation.
+
+        Args:
+            context: Shared context for the action execution
+            task_id: The task ID to process
+            task_data: The task data dictionary
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict with 'success' boolean and optional 'error' message
+        """
+        try:
+            client = context.client
+            logger = context.logger
+
+            # Get pre-processor ID from parameters
+            pre_processor_id = context.params.get('pre_processor')
+            if not pre_processor_id:
+                error_msg = 'Pre-processor ID is required for inference annotation method'
+                logger.log_annotate_task_event(LogCode.NO_PREPROCESSOR_ID, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Get pre-processor info using factory-created strategy
+            from ..factory import ToTaskStrategyFactory
+
+            factory = ToTaskStrategyFactory()
+            preprocessor_strategy = factory.create_preprocessor_strategy()
+
+            pre_processor_info = preprocessor_strategy.get_preprocessor_info(context, pre_processor_id)
+            if not pre_processor_info['success']:
+                error_msg = pre_processor_info.get('error', 'Failed to get pre-processor info')
+                logger.log_annotate_task_event(LogCode.INFERENCE_PREPROCESSOR_FAILED, task_id, error_msg)
+                return pre_processor_info
+
+            pre_processor_code = pre_processor_info['code']
+            pre_processor_version = pre_processor_info['version']
+
+            # Ensure pre-processor is running
+            pre_processor_status = preprocessor_strategy.ensure_preprocessor_running(context, pre_processor_code)
+            if not pre_processor_status['success']:
+                error_msg = pre_processor_status.get('error', 'Failed to ensure pre-processor running')
+                logger.log_annotate_task_event(LogCode.INFERENCE_PREPROCESSOR_FAILED, task_id, error_msg)
+                return pre_processor_status
+
+            # Extract primary file URL using factory-created strategy
+            extraction_strategy = factory.create_extraction_strategy(context.annotation_method)
+            primary_file_url, _ = extraction_strategy.extract_data(context, task_data)
+            if not primary_file_url:
+                error_msg = 'Primary image URL not found in task data'
+                logger.log_annotate_task_event(LogCode.PRIMARY_IMAGE_URL_NOT_FOUND, task_id)
+                logger.log_annotate_task_data({'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED)
+                return {'success': False, 'error': error_msg}
+
+            # Run inference
+            inference_result = self._run_inference(
+                client,
+                pre_processor_code,
+                pre_processor_version,
+                primary_file_url,
+                context.params['agent'],
+                context.params['model'],
+                pre_processor_params=context.params.get('pre_processor_params', {}),
+            )
+            if not inference_result['success']:
+                error_msg = inference_result.get('error', 'Failed to run inference')
+                logger.log_annotate_task_event(LogCode.INFERENCE_PREPROCESSOR_FAILED, task_id, error_msg)
+                return inference_result
+
+            # Convert and submit inference data
+            try:
+                # This would need to be injected or configured based on the action's entrypoint
+                # For now, we'll assume the conversion is done externally
+                converted_result = inference_result['data']  # Simplified for refactoring
+
+                client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_result})
+                logger.log_annotate_task_data(
+                    {'task_id': task_id, 'pre_processor_id': pre_processor_id}, AnnotateTaskDataStatus.SUCCESS
+                )
+                return {'success': True, 'pre_processor_id': pre_processor_id}
+
+            except Exception as e:
+                error_msg = f'Failed to convert/submit inference data: {str(e)}'
+                logger.log_annotate_task_event(LogCode.INFERENCE_PREPROCESSOR_FAILED, task_id, error_msg)
+                return {'success': False, 'error': error_msg}
+
+        except Exception as e:
+            error_msg = f'Failed to process inference for task {task_id}: {str(e)}'
+            context.logger.log_message_with_code(LogCode.INFERENCE_PROCESSING_FAILED, task_id, str(e))
+            context.logger.log_annotate_task_data(
+                {'task_id': task_id, 'error': error_msg}, AnnotateTaskDataStatus.FAILED
+            )
+            return {'success': False, 'error': error_msg}
+
+    def _run_inference(
+        self,
+        client: Any,
+        pre_processor_code: str,
+        pre_processor_version: str,
+        primary_file_url: str,
+        agent: int,
+        model: int,
+        pre_processor_params: Dict[str, Any] = {},
+    ) -> Dict[str, Any]:
+        """Run inference using the pre-processor.
+
+        Args:
+            client: Backend client instance
+            pre_processor_code: Pre-processor code
+            pre_processor_version: Pre-processor version
+            primary_file_url: URL of the primary file to process
+            agent: Agent id for inference
+            model: Model id for inference
+            pre_processor_params: Additional parameters for the pre-processor
+
+        Returns:
+            Dict with inference results or error
+        """
+        try:
+            if not agent or not model:
+                return {'success': False, 'error': 'Parameters not available'}
+
+            pre_processor_params['image_path'] = primary_file_url
+
+            inference_payload = {
+                'agent': agent,
+                'action': 'inference',
+                'version': pre_processor_version,
+                'params': {
+                    'model': model,
+                    'method': 'post',
+                    'json': pre_processor_params,
+                },
+            }
+
+            inference_data = client.run_plugin(pre_processor_code, inference_payload)
+
+            # Every inference api should return None if failed to inference.
+            if inference_data is None:
+                return {'success': False, 'error': 'Inference data is None'}
+
+            return {'success': True, 'data': inference_data}
+
+        except Exception as e:
+            return {'success': False, 'error': f'Failed to run inference: {str(e)}'}

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))