synapse-sdk 1.0.0b5__py3-none-any.whl → 2025.12.3__py3-none-any.whl

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

@@ -0,0 +1,248 @@
+"""Orchestrator for coordinating ToTask action workflow using Facade pattern."""
+
+from typing import Any, Dict
+
+from synapse_sdk.clients.backend.models import JobStatus
+
+from .enums import AnnotationMethod, LogCode
+from .exceptions import CriticalError, PreAnnotationToTaskFailed
+from .factory import ToTaskStrategyFactory
+from .models import ToTaskResult
+from .strategies.base import ToTaskContext
+
+
+class ToTaskOrchestrator:
+    """Facade that orchestrates the complete ToTask annotation workflow."""
+
+    def __init__(self, context: ToTaskContext):
+        """Initialize orchestrator with context and strategies.
+
+        Args:
+            context: Shared context for the action execution
+        """
+        self.context = context
+        self.factory = ToTaskStrategyFactory()
+        self.steps_completed = []
+
+        # Initialize strategies
+        self.project_validation = self.factory.create_validation_strategy('project')
+        self.task_validation = self.factory.create_validation_strategy('task')
+        self.target_spec_validation = self.factory.create_validation_strategy('target_spec')
+        self.metrics_strategy = self.factory.create_metrics_strategy()
+
+    def execute_workflow(self) -> Dict[str, Any]:
+        """Execute the complete ToTask workflow with rollback support.
+
+        Returns:
+            Dict containing the workflow result
+        """
+        try:
+            # Step 1: Project and data collection validation
+            self._execute_step('project_validation', self._validate_project)
+
+            # Step 2: Task discovery and validation
+            self._execute_step('task_validation', self._validate_tasks)
+
+            # Step 3: Determine annotation method
+            self._execute_step('method_determination', self._determine_annotation_method)
+
+            # Step 4: Method-specific validation
+            self._execute_step('method_validation', self._validate_annotation_method)
+
+            # Step 5: Initialize processing
+            self._execute_step('processing_initialization', self._initialize_processing)
+
+            # Step 6: Process all tasks
+            self._execute_step('task_processing', self._process_all_tasks)
+
+            # Step 7: Finalize metrics and progress
+            self._execute_step('finalization', self._finalize_processing)
+
+            # Return success result
+            result = ToTaskResult(status=JobStatus.SUCCEEDED, message='Pre-annotation to task completed successfully')
+            return result.model_dump()
+
+        except Exception as e:
+            # Mark progress as failed with elapsed time
+            self.context.logger.set_progress_failed(category='annotate_task_data')
+            self._rollback_completed_steps()
+            if isinstance(e, PreAnnotationToTaskFailed):
+                raise e
+            raise PreAnnotationToTaskFailed(f'Workflow failed at step {len(self.steps_completed)}: {e}')
+
+    def _execute_step(self, step_name: str, step_func: callable):
+        """Execute a workflow step with error handling and progress tracking.
+
+        Args:
+            step_name: Name of the step for logging
+            step_func: Function to execute for this step
+
+        Returns:
+            Result of the step function
+        """
+        self.context.logger.log_message_with_code(LogCode.STEP_STARTED, step_name)
+
+        try:
+            result = step_func()
+            self.steps_completed.append(step_name)
+            self.context.logger.log_message_with_code(LogCode.STEP_COMPLETED, step_name)
+            return result
+        except Exception as e:
+            self.context.logger.log_message_with_code(LogCode.STEP_FAILED, step_name, str(e))
+            raise
+
+    def _validate_project(self):
+        """Step 1: Validate project and data collection."""
+        result = self.project_validation.validate(self.context)
+        if not result['success']:
+            error_msg = result.get('error', 'Project validation failed')
+            raise PreAnnotationToTaskFailed(error_msg)
+
+    def _validate_tasks(self):
+        """Step 2: Discover and validate tasks."""
+        result = self.task_validation.validate(self.context)
+        if not result['success']:
+            error_msg = result.get('error', 'Task validation failed')
+            raise PreAnnotationToTaskFailed(error_msg)
+
+    def _determine_annotation_method(self):
+        """Step 3: Determine annotation method from parameters."""
+        method = self.context.params.get('method')
+        if method == AnnotationMethod.FILE:
+            self.context.annotation_method = AnnotationMethod.FILE
+        elif method == AnnotationMethod.INFERENCE:
+            self.context.annotation_method = AnnotationMethod.INFERENCE
+        else:
+            self.context.logger.log_message_with_code(LogCode.UNSUPPORTED_METHOD, method)
+            raise PreAnnotationToTaskFailed(f'Unsupported annotation method: {method}')
+
+    def _validate_annotation_method(self):
+        """Step 4: Validate method-specific requirements."""
+        if self.context.annotation_method == AnnotationMethod.FILE:
+            result = self.target_spec_validation.validate(self.context)
+            if not result['success']:
+                error_msg = result.get('error', 'Target specification validation failed')
+                raise PreAnnotationToTaskFailed(error_msg)
+
+    def _initialize_processing(self):
+        """Step 5: Initialize processing metrics and progress."""
+        total_tasks = len(self.context.task_ids)
+        self.context.update_metrics(0, 0, total_tasks)
+        self.metrics_strategy.update_progress(self.context, 0, total_tasks)
+        self.context.logger.log_message_with_code(LogCode.ANNOTATING_DATA)
+
+    def _process_all_tasks(self):
+        """Step 6: Process all tasks using appropriate annotation strategy."""
+        annotation_strategy = self.factory.create_annotation_strategy(self.context.annotation_method)
+
+        total_tasks = len(self.context.task_ids)
+        success_count = 0
+        failed_count = 0
+        current_progress = 0
+
+        # Get task parameters
+        task_params = {
+            'fields': 'id,data,data_unit',
+            'expand': 'data_unit',
+        }
+
+        # Process each task
+        for task_id in self.context.task_ids:
+            try:
+                # Get task data
+                task_response = self.context.client.get_task(task_id, params=task_params)
+                if isinstance(task_response, str):
+                    error_msg = 'Invalid task response'
+                    self.context.logger.log_annotate_task_event(LogCode.INVALID_TASK_RESPONSE, task_id)
+                    self.metrics_strategy.record_task_result(self.context, task_id, False, error_msg)
+                    failed_count += 1
+                    continue
+
+                task_data: Dict[str, Any] = task_response
+
+                # Process task using annotation strategy
+                if self.context.annotation_method == AnnotationMethod.FILE:
+                    target_spec_name = self.context.params.get('target_specification_name')
+                    result = annotation_strategy.process_task(
+                        self.context, task_id, task_data, target_specification_name=target_spec_name
+                    )
+                else:
+                    result = annotation_strategy.process_task(self.context, task_id, task_data)
+
+                # Record result
+                if result['success']:
+                    success_count += 1
+                    self.metrics_strategy.record_task_result(self.context, task_id, True)
+                else:
+                    failed_count += 1
+                    error_msg = result.get('error', 'Unknown error')
+                    self.metrics_strategy.record_task_result(self.context, task_id, False, error_msg)
+
+                # Update progress
+                current_progress += 1
+                self.context.update_metrics(success_count, failed_count, total_tasks)
+                self.metrics_strategy.update_progress(self.context, current_progress, total_tasks)
+                self.metrics_strategy.update_metrics(self.context, total_tasks, success_count, failed_count)
+
+            except CriticalError:
+                self.context.logger.log_message_with_code(LogCode.CRITICAL_ERROR)
+                raise PreAnnotationToTaskFailed('Critical error occurred during task processing')
+
+            except Exception as e:
+                self.context.logger.log_annotate_task_event(LogCode.TASK_PROCESSING_FAILED, task_id, str(e))
+                self.metrics_strategy.record_task_result(self.context, task_id, False, str(e))
+                failed_count += 1
+                current_progress += 1
+                self.context.update_metrics(success_count, failed_count, total_tasks)
+                self.metrics_strategy.update_progress(self.context, current_progress, total_tasks)
+                self.metrics_strategy.update_metrics(self.context, total_tasks, success_count, failed_count)
+
+    def _finalize_processing(self):
+        """Step 7: Finalize metrics."""
+        # Finalize metrics
+        self.metrics_strategy.finalize_metrics(self.context)
+
+    def _rollback_completed_steps(self):
+        """Rollback completed steps in reverse order."""
+        for step in reversed(self.steps_completed):
+            try:
+                rollback_method = getattr(self, f'_rollback_{step}', None)
+                if rollback_method:
+                    rollback_method()
+            except Exception as e:
+                self.context.logger.log_message_with_code(LogCode.ROLLBACK_FAILED, step, str(e))
+
+        # Execute any additional rollback actions
+        for action in reversed(self.context.rollback_actions):
+            try:
+                action()
+            except Exception as e:
+                self.context.logger.log_message_with_code(LogCode.ROLLBACK_ACTION_FAILED, str(e))
+
+    def _rollback_project_validation(self):
+        """Rollback project validation step."""
+        # Clear cached project and data collection data
+        self.context.project = None
+        self.context.data_collection = None
+
+    def _rollback_task_validation(self):
+        """Rollback task validation step."""
+        # Clear cached task data
+        self.context.task_ids = []
+
+    def _rollback_processing_initialization(self):
+        """Rollback processing initialization step."""
+        # Reset metrics
+        self.context.update_metrics(0, 0, 0)
+
+    def _rollback_task_processing(self):
+        """Rollback task processing step."""
+        # Clean up any temporary files
+        for temp_file in self.context.temp_files:
+            try:
+                import os
+
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+            except Exception:
+                pass  # Best effort cleanup

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

@@ -0,0 +1,64 @@
+import json
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from synapse_sdk.plugins.models import Run
+from synapse_sdk.shared.enums import Context
+
+from .enums import LOG_MESSAGES, AnnotateTaskDataStatus, LogCode
+from .models import AnnotateTaskDataLog, AnnotateTaskEventLog, MetricsRecord
+
+
+class ToTaskRun(Run):
+    def log_message_with_code(self, code: LogCode, *args, level: Optional[Context] = None):
+        """Log message using predefined code and optional level override."""
+        if code not in LOG_MESSAGES:
+            self.log_message(f'Unknown log code: {code}')
+            return
+
+        log_config = LOG_MESSAGES[code]
+        message = log_config['message'].format(*args) if args else log_config['message']
+        log_level = level or log_config['level']
+
+        if log_level:
+            self.log_message(message, context=log_level.value)
+        else:
+            self.log_message(message, context=Context.INFO.value)
+
+    def log_annotate_task_event(self, code: LogCode, *args, level: Optional[Context] = None):
+        """Log annotate task event using predefined code."""
+        if code not in LOG_MESSAGES:
+            now = datetime.now().isoformat()
+            self.log(
+                'annotate_task_event',
+                AnnotateTaskEventLog(info=f'Unknown log code: {code}', status=Context.DANGER, created=now).model_dump(),
+            )
+            return
+
+        log_config = LOG_MESSAGES[code]
+        message = log_config['message'].format(*args) if args else log_config['message']
+        log_level = level or log_config['level'] or Context.INFO
+
+        now = datetime.now().isoformat()
+        self.log(
+            'annotate_task_event',
+            AnnotateTaskEventLog(info=message, status=log_level, created=now).model_dump(),
+        )
+
+    def log_annotate_task_data(self, task_info: Dict[str, Any], status: AnnotateTaskDataStatus):
+        """Log annotate task data."""
+        now = datetime.now().isoformat()
+        self.log(
+            'annotate_task_data',
+            AnnotateTaskDataLog(task_info=json.dumps(task_info), status=status, created=now).model_dump(),
+        )
+
+    def log_metrics(self, record: MetricsRecord, category: str):
+        """Log FileToTask metrics.
+
+        Args:
+            record (MetricsRecord): The metrics record to log.
+            category (str): The category of the metrics.
+        """
+        record = MetricsRecord.model_validate(record)
+        self.set_metrics(value=record.model_dump(), category=category)

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

@@ -0,0 +1,17 @@
+"""Strategy classes for ToTask action refactoring."""
+
+from .base import (
+    AnnotationStrategy,
+    DataExtractionStrategy,
+    MetricsStrategy,
+    PreProcessorStrategy,
+    ValidationStrategy,
+)
+
+__all__ = [
+    'AnnotationStrategy',
+    'DataExtractionStrategy',
+    'MetricsStrategy',
+    'PreProcessorStrategy',
+    'ValidationStrategy',
+]

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

@@ -0,0 +1,265 @@
+"""Annotation strategies for ToTask action."""
+
+from typing import Any, Dict
+
+from ..enums import 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)
+                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)
+                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)
+                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)
+                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)
+                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)
+                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)
+                return {'success': False, 'error': error_msg}
+
+            # Submit annotation data
+            try:
+                client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_data})
+                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))
+                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))
+            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)
+                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)
+                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
+                inference_data = inference_result['data']  # Simplified for refactoring
+
+                annotation_to_task = context.entrypoint(logger)
+                converted_result = annotation_to_task.convert_data_from_inference(inference_data)
+
+                client.annotate_task_data(task_id, data={'action': 'submit', 'data': converted_result})
+                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))
+            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)}'}