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/exceptions.py

@@ -0,0 +1,14 @@
+class CriticalError(Exception):
+    """Critical error."""
+
+    def __init__(self, message: str = 'Critical error occured while processing task'):
+        self.message = message
+        super().__init__(self.message)
+
+
+class PreAnnotationToTaskFailed(Exception):
+    """Pre-annotation to task failed."""
+
+    def __init__(self, message: str = 'Pre-annotation to task failed'):
+        self.message = message
+        super().__init__(self.message)

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

@@ -0,0 +1,76 @@
+"""Factory for creating ToTask strategies based on context."""
+
+from typing import Dict, Type
+
+from .enums import AnnotationMethod
+from .strategies.base import (
+    AnnotationStrategy,
+    DataExtractionStrategy,
+    MetricsStrategy,
+    PreProcessorStrategy,
+    ValidationStrategy,
+)
+
+
+class ToTaskStrategyFactory:
+    """Factory for creating action strategies based on context."""
+
+    def __init__(self):
+        # Import strategies here to avoid circular imports
+        from .strategies.annotation import FileAnnotationStrategy, InferenceAnnotationStrategy
+        from .strategies.extraction import FileUrlExtractionStrategy, InferenceDataExtractionStrategy
+        from .strategies.metrics import ProgressTrackingStrategy
+        from .strategies.preprocessor import PreProcessorManagementStrategy
+        from .strategies.validation import (
+            ProjectValidationStrategy,
+            TargetSpecificationValidationStrategy,
+            TaskValidationStrategy,
+        )
+
+        self._annotation_strategies: Dict[AnnotationMethod, Type[AnnotationStrategy]] = {
+            AnnotationMethod.FILE: FileAnnotationStrategy,
+            AnnotationMethod.INFERENCE: InferenceAnnotationStrategy,
+        }
+
+        self._validation_strategies = {
+            'project': ProjectValidationStrategy,
+            'task': TaskValidationStrategy,
+            'target_spec': TargetSpecificationValidationStrategy,
+        }
+
+        self._extraction_strategies = {
+            AnnotationMethod.FILE: FileUrlExtractionStrategy,
+            AnnotationMethod.INFERENCE: InferenceDataExtractionStrategy,
+        }
+
+        self._preprocessor_strategy = PreProcessorManagementStrategy
+        self._metrics_strategy = ProgressTrackingStrategy
+
+    def create_annotation_strategy(self, method: AnnotationMethod) -> AnnotationStrategy:
+        """Create annotation strategy based on method."""
+        strategy_class = self._annotation_strategies.get(method)
+        if not strategy_class:
+            raise ValueError(f'No annotation strategy available for method: {method}')
+        return strategy_class()
+
+    def create_validation_strategy(self, validation_type: str) -> ValidationStrategy:
+        """Create validation strategy based on type."""
+        strategy_class = self._validation_strategies.get(validation_type)
+        if not strategy_class:
+            raise ValueError(f'No validation strategy available for type: {validation_type}')
+        return strategy_class()
+
+    def create_extraction_strategy(self, method: AnnotationMethod) -> DataExtractionStrategy:
+        """Create data extraction strategy based on method."""
+        strategy_class = self._extraction_strategies.get(method)
+        if not strategy_class:
+            raise ValueError(f'No extraction strategy available for method: {method}')
+        return strategy_class()
+
+    def create_preprocessor_strategy(self) -> PreProcessorStrategy:
+        """Create pre-processor management strategy."""
+        return self._preprocessor_strategy()
+
+    def create_metrics_strategy(self) -> MetricsStrategy:
+        """Create metrics tracking strategy."""
+        return self._metrics_strategy()

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

@@ -0,0 +1,97 @@
+from typing import Annotated, Any, Dict, Optional
+
+from pydantic import AfterValidator, BaseModel, field_validator
+from pydantic_core import PydanticCustomError
+
+from synapse_sdk.clients.backend.models import JobStatus
+from synapse_sdk.clients.exceptions import ClientError
+from synapse_sdk.shared.enums import Context
+from synapse_sdk.utils.pydantic.validators import non_blank
+
+from .enums import AnnotateTaskDataStatus
+
+
+class ToTaskParams(BaseModel):
+    """ToTask action parameters.
+
+    Args:
+        name (str): The name of the action.
+        description (str | None): The description of the action.
+        project (int): The project ID.
+        agent (int): The agent ID.
+        task_filters (dict): The filters of tasks.
+        method (AnnotationMethod): The method of annotation.
+        target_specification_name (str | None): The name of the target specification.
+        model (int): The model ID.
+        pre_processor (int | None): The pre processor ID.
+        pre_processor_params (dict): The params of the pre processor.
+    """
+
+    name: Annotated[str, AfterValidator(non_blank)]
+    description: Optional[str] = None
+    project: int
+    agent: int
+    task_filters: Dict[str, Any]
+    method: Optional[str] = None
+    target_specification_name: Optional[str] = None
+    model: Optional[int] = None
+    pre_processor: Optional[int] = None
+    pre_processor_params: Dict[str, Any]
+
+    @field_validator('project', mode='before')
+    @classmethod
+    def check_project_exists(cls, value: int, info) -> int:
+        """Validate synapse-backend project exists."""
+        if not value:
+            return value
+
+        action = info.context['action']
+        client = action.client
+        try:
+            client.get_project(value)
+        except ClientError:
+            raise PydanticCustomError('client_error', 'Error occurred while checking project exists.')
+        return value
+
+
+class ToTaskResult(BaseModel):
+    """Result model for ToTaskAction.start method.
+
+    Args:
+        status (JobStatus): The job status from the action execution.
+        message (str): A descriptive message about the action result.
+    """
+
+    status: JobStatus
+    message: str
+
+    def model_dump(self, **kwargs):
+        """Override model_dump to return status as enum value."""
+        data = super().model_dump(**kwargs)
+        if 'status' in data and isinstance(data['status'], JobStatus):
+            data['status'] = data['status'].value
+        return data
+
+
+class AnnotateTaskEventLog(BaseModel):
+    """Annotate task event log model."""
+
+    info: Optional[str] = None
+    status: Context
+    created: str
+
+
+class AnnotateTaskDataLog(BaseModel):
+    """Log model for annotate task data."""
+
+    task_info: Optional[str] = None
+    status: AnnotateTaskDataStatus
+    created: str
+
+
+class MetricsRecord(BaseModel):
+    """Metrics record model."""
+
+    stand_by: int
+    failed: int
+    success: int

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

@@ -0,0 +1,250 @@
+"""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:
+            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')
+            self.context.logger.end_log()
+            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')
+            self.context.logger.end_log()
+            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)
+            self.context.logger.end_log()
+            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')
+                self.context.logger.end_log()
+                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',
+]