synapse-sdk 2025.10.1__py3-none-any.whl → 2025.10.4__py3-none-any.whl

synapse_sdk/plugins/categories/export/actions/export/action.py

@@ -95,11 +95,11 @@ class ExportAction(Action):
             PydanticCustomError: If data retrieval fails
         """
         try:
-            result_list = handler.get_results(self.client, filters)
+            result_list = handler.get_results(self.client, filters, run=self.run)
             results = result_list[0]
             count = result_list[1]
         except ClientError:
-            raise PydanticCustomError('client_error', _('Unable to get Ground Truth dataset.'))
+            raise PydanticCustomError('client_error', _('Unable to get dataset.'))
         return results, count
 
     def start(self) -> Dict[str, Any]:
@@ -116,7 +116,12 @@ class ExportAction(Action):
         """
         self.run.log_message_with_code(LogCode.EXPORT_STARTED)
 
-        filters = {'expand': 'data', **self.params['filter']}
+        # Get expand setting from config, default to True (expand data)
+        filters = {**self.params['filter']}
+        data_expand = self.config.get('data_expand', True)
+        if data_expand:
+            filters['expand'] = 'data'
+
         target = self.params['target']
         handler = TargetHandlerFactory.get_handler(target)
 

synapse_sdk/plugins/categories/export/actions/export/utils.py

@@ -1,10 +1,12 @@
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Optional
+import time
 
 from pydantic_core import PydanticCustomError
 
 from synapse_sdk.clients.exceptions import ClientError
 from synapse_sdk.i18n import gettext as _
+from synapse_sdk.shared.enums import Context
 
 
 class ExportTargetHandler(ABC):
@@ -15,6 +17,103 @@ class ExportTargetHandler(ABC):
     of methods to validate filters, retrieve results, and process collections of results.
     """
 
+    # TODO: This is a temporary workaround and needs improvement in the future
+    def _get_results_chunked(self, list_method, filters, chunk_size=100, max_retries=3, retry_delay=1, run=None):
+        """
+        Retrieve results in chunks to avoid memory and response size limits.
+
+        Args:
+            list_method: The client method to call (e.g., client.list_assignments)
+            filters (dict): The filter criteria to apply
+            chunk_size (int): Number of items to fetch per chunk
+            max_retries (int): Maximum number of retries for failed requests
+            retry_delay (int): Delay in seconds between retries
+
+        Returns:
+            tuple: A tuple containing the results generator and the total count
+        """
+        filters = filters.copy()
+        filters['page_size'] = chunk_size
+
+        page = 1
+        results = []
+        total_count = 0
+
+        try:
+            while True:
+                filters['page'] = page
+
+                # Retry logic for handling temporary server issues
+                for attempt in range(max_retries + 1):
+                    try:
+                        response = list_method(params=filters, list_all=False)
+                        break
+                    except ClientError as e:
+                        error_msg = str(e)
+
+                        # Use log_dev_event for better debugging and monitoring
+                        if run:
+                            run.log_dev_event(
+                                'Chunked data retrieval error',
+                                {
+                                    'page': page,
+                                    'attempt': attempt + 1,
+                                    'error_message': error_msg,
+                                    'chunk_size': chunk_size,
+                                },
+                                level=Context.WARNING,
+                            )
+
+                        # Check for JSON decode errors specifically
+                        if 'Expecting value' in error_msg or 'JSONDecodeError' in error_msg:
+                            if run:
+                                run.log_dev_event(
+                                    'JSON parsing error - skipping page',
+                                    {'page': page, 'error_type': 'JSON_DECODE_ERROR', 'error_details': error_msg},
+                                    level=Context.DANGER,
+                                )
+                            # Skip this page and continue with next
+                            page += 1
+                            break
+                        elif attempt < max_retries and ('503' in error_msg or 'connection' in error_msg.lower()):
+                            retry_delay_seconds = retry_delay * (2**attempt)
+                            if run:
+                                run.log_dev_event(
+                                    'Server issue - retrying with backoff',
+                                    {
+                                        'page': page,
+                                        'retry_attempt': attempt + 1,
+                                        'max_retries': max_retries,
+                                        'retry_delay_seconds': retry_delay_seconds,
+                                        'error_type': 'SERVER_ISSUE',
+                                    },
+                                    level=Context.INFO,
+                                )
+                            time.sleep(retry_delay_seconds)  # Exponential backoff
+                            continue
+                        else:
+                            raise
+
+                if page == 1:
+                    total_count = response['count']
+
+                current_results = response.get('results', [])
+                results.extend(current_results)
+
+                # Check if we've got all results or if there are no more results
+                if len(current_results) < chunk_size or not response.get('next'):
+                    break
+
+                page += 1
+
+                # Small delay between pages to avoid overwhelming the server
+                time.sleep(0.1)
+
+            return results, total_count
+        except Exception:
+            # Re-raise the exception to be handled by the calling method
+            raise
+
     @abstractmethod
     def validate_filter(self, value: dict, client: Any):
         """
@@ -33,13 +132,14 @@ class ExportTargetHandler(ABC):
         pass
 
     @abstractmethod
-    def get_results(self, client: Any, filters: dict):
+    def get_results(self, client: Any, filters: dict, run=None):
         """
         Retrieve original data from target sources.
 
         Args:
             client (Any): The client used to retrieve the results.
             filters (dict): The filter criteria to apply.
+            run: Optional ExportRun instance for logging.
 
         Returns:
             tuple: A tuple containing the results and the total count of results.
@@ -76,8 +176,8 @@ class AssignmentExportTargetHandler(ExportTargetHandler):
             raise PydanticCustomError('client_error', _('Unable to get Assignment.'))
         return value
 
-    def get_results(self, client: Any, filters: dict):
-        return client.list_assignments(params=filters, list_all=True)
+    def get_results(self, client: Any, filters: dict, run=None):
+        return self._get_results_chunked(client.list_assignments, filters, run=run)
 
     def get_export_item(self, results):
         for result in results:
@@ -104,9 +204,9 @@ class GroundTruthExportTargetHandler(ExportTargetHandler):
             raise PydanticCustomError('client_error', _('Unable to get Ground Truth dataset version.'))
         return value
 
-    def get_results(self, client: Any, filters: dict):
+    def get_results(self, client: Any, filters: dict, run=None):
         filters['ground_truth_dataset_versions'] = filters.pop('ground_truth_dataset_version')
-        return client.list_ground_truth_events(params=filters, list_all=True)
+        return self._get_results_chunked(client.list_ground_truth_events, filters, run=run)
 
     def get_export_item(self, results):
         for result in results:
@@ -134,9 +234,9 @@ class TaskExportTargetHandler(ExportTargetHandler):
             raise PydanticCustomError('client_error', _('Unable to get Task.'))
         return value
 
-    def get_results(self, client: Any, filters: dict):
+    def get_results(self, client: Any, filters: dict, run=None):
         filters['expand'] = ['data_unit', 'assignment', 'workshop']
-        return client.list_tasks(params=filters, list_all=True)
+        return self._get_results_chunked(client.list_tasks, filters, run=run)
 
     def get_export_item(self, results):
         for result in results:

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

@@ -0,0 +1,4 @@
+from .pre_annotation.action import PreAnnotationAction
+from .to_task.action import ToTaskAction
+
+__all__ = ['PreAnnotationAction', 'ToTaskAction']

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

@@ -0,0 +1,3 @@
+from .action import PreAnnotationAction
+
+__all__ = ['PreAnnotationAction']

synapse_sdk/plugins/categories/pre_annotation/actions/pre_annotation/action.py

@@ -0,0 +1,10 @@
+from synapse_sdk.plugins.categories.base import Action
+from synapse_sdk.plugins.categories.decorators import register_action
+from synapse_sdk.plugins.enums import PluginCategory, RunMethod
+
+
+@register_action
+class PreAnnotationAction(Action):
+    name = 'pre_annotation'
+    category = PluginCategory.PRE_ANNOTATION
+    method = RunMethod.TASK

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

@@ -0,0 +1,28 @@
+from .action import ToTaskAction
+from .enums import AnnotateTaskDataStatus, AnnotationMethod, LogCode
+from .exceptions import CriticalError, PreAnnotationToTaskFailed
+
+# Advanced imports for extending the system
+from .factory import ToTaskStrategyFactory
+from .models import MetricsRecord, ToTaskParams, ToTaskResult
+from .orchestrator import ToTaskOrchestrator
+from .run import ToTaskRun
+from .strategies.base import ToTaskContext
+
+__all__ = [
+    # Core public API (maintains backward compatibility)
+    'ToTaskAction',
+    'ToTaskRun',
+    'ToTaskParams',
+    'ToTaskResult',
+    'AnnotationMethod',
+    'AnnotateTaskDataStatus',
+    'LogCode',
+    'CriticalError',
+    'PreAnnotationToTaskFailed',
+    'MetricsRecord',
+    # Advanced components for customization and testing
+    'ToTaskOrchestrator',
+    'ToTaskContext',
+    'ToTaskStrategyFactory',
+]

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

@@ -0,0 +1,145 @@
+"""Refactored ToTask action using Strategy and Facade patterns."""
+
+from typing import Dict
+
+from synapse_sdk.clients.backend import BackendClient
+from synapse_sdk.clients.backend.models import JobStatus
+from synapse_sdk.plugins.categories.base import Action
+from synapse_sdk.plugins.categories.decorators import register_action
+from synapse_sdk.plugins.enums import PluginCategory, RunMethod
+
+from .enums import LogCode
+from .exceptions import PreAnnotationToTaskFailed
+from .models import ToTaskParams, ToTaskResult
+from .orchestrator import ToTaskOrchestrator
+from .run import ToTaskRun
+from .strategies.base import ToTaskContext
+
+
+@register_action
+class ToTaskAction(Action):
+    """ToTask action for pre-annotation data processing using Strategy and Facade patterns.
+
+    This action handles the process of annotating data to tasks in a project. It supports
+    two annotation methods: file-based annotation and inference-based annotation.
+
+    The action uses a Strategy pattern to handle different annotation methods and validation
+    approaches, coordinated by an Orchestrator (Facade pattern) that manages the complete
+    workflow with rollback capabilities.
+
+    File-based annotation fetches data from file URLs specified in task data units,
+    downloads and processes JSON data, and updates task data with the processed information.
+    It also validates target specification names against file specifications.
+
+    Inference-based annotation uses pre-processor plugins for model inference
+    for automatic data annotation.
+
+    Attrs:
+        name (str): Action name, set to 'to_task'.
+        category (PluginCategory): Plugin category, set to PRE_ANNOTATION.
+        method (RunMethod): Execution method, set to JOB.
+        run_class (Type[ToTaskRun]): Run class for this action.
+        params_model (Type[ToTaskParams]): Parameter validation model.
+        progress_categories (Dict): Progress tracking configuration.
+        metrics_categories (Set[str]): Metrics categories for this action.
+
+    Note:
+        This action requires a valid project with an associated data collection.
+        For file-based annotation, the target_specification_name must exist in the
+        project's file specifications.
+
+    Raises:
+        ValueError: If run instance or parameters are not properly initialized.
+        PreAnnotationToTaskFailed: If the annotation workflow fails.
+    """
+
+    name = 'to_task'
+    category = PluginCategory.PRE_ANNOTATION
+    method = RunMethod.JOB
+    run_class = ToTaskRun
+    params_model = ToTaskParams
+    progress_categories = {
+        'annotate_task_data': {
+            'proportion': 100,
+        },
+    }
+    metrics_categories = {
+        'annotate_task_data': {
+            'stand_by': 0,
+            'failed': 0,
+            'success': 0,
+        }
+    }
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the action with orchestrator context."""
+        super().__init__(*args, **kwargs)
+        self.context = None
+
+    def start(self) -> Dict:
+        """Start to_task action using orchestrator facade.
+
+        The action now uses a simplified workflow:
+        1. Validate initialization
+        2. Create execution context
+        3. Execute workflow through orchestrator
+        4. Handle results and errors
+
+        Returns:
+            dict: Validated result with status and message.
+        """
+        # Validate initialization
+        if not self.run or not self.params:
+            result = ToTaskResult(
+                status=JobStatus.FAILED, message='Run instance or parameters not properly initialized'
+            )
+            raise PreAnnotationToTaskFailed(result.message)
+
+        # Type assertions for better IDE support
+        assert isinstance(self.run, ToTaskRun)
+        assert isinstance(self.run.client, BackendClient)
+
+        # Log action start
+        self.run.log_message_with_code(LogCode.TO_TASK_STARTED)
+
+        try:
+            # Create execution context
+            self.context = ToTaskContext(
+                params=self.params,
+                client=self.run.client,
+                logger=self.run,
+                entrypoint=self.entrypoint,
+                config=self.config,
+                plugin_config=self.plugin_config,
+                job_id=self.job_id,
+                progress_categories=self.progress_categories,
+                metrics_categories=self.metrics_categories,
+            )
+
+            # Create and execute orchestrator
+            orchestrator = ToTaskOrchestrator(self.context)
+            result = orchestrator.execute_workflow()
+
+            # Log successful completion
+            self.run.log_message_with_code(LogCode.TO_TASK_COMPLETED)
+            return result
+
+        except PreAnnotationToTaskFailed as e:
+            # Re-raise pre-annotation specific errors
+            self.run.log_message_with_code(LogCode.TO_TASK_FAILED, str(e))
+            raise e
+
+        except Exception as e:
+            # Handle unexpected errors
+            error_msg = f'ToTask action failed: {str(e)}'
+            self.run.log_message_with_code(LogCode.TO_TASK_FAILED, error_msg)
+            result = ToTaskResult(status=JobStatus.FAILED, message=error_msg)
+            raise PreAnnotationToTaskFailed(result.message)
+
+    def get_context(self) -> ToTaskContext:
+        """Get the current execution context for testing/debugging.
+
+        Returns:
+            ToTaskContext: The current execution context, or None if not initialized.
+        """
+        return self.context

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

@@ -0,0 +1,269 @@
+from enum import Enum
+
+from synapse_sdk.shared.enums import Context
+
+
+class AnnotationMethod(str, Enum):
+    FILE = 'file'
+    INFERENCE = 'inference'
+
+
+class AnnotateTaskDataStatus(str, Enum):
+    SUCCESS = 'success'
+    FAILED = 'failed'
+
+
+class LogCode(str, Enum):
+    """Type-safe logging codes for to_task operations.
+
+    Enumeration of all possible log events during to_task processing. Each code
+    corresponds to a specific event or error state with predefined message
+    templates and log levels.
+
+    The codes are organized by category:
+    - Validation codes (INVALID_PROJECT_RESPONSE, NO_DATA_COLLECTION, etc.)
+    - Processing codes (ANNOTATING_DATA, ANNOTATION_COMPLETED, etc.)
+    - Error codes (CRITICAL_ERROR, TASK_PROCESSING_FAILED, etc.)
+    - Inference codes (ANNOTATING_INFERENCE_DATA, INFERENCE_PROCESSING_FAILED, etc.)
+    """
+
+    INVALID_PROJECT_RESPONSE = 'INVALID_PROJECT_RESPONSE'
+    NO_DATA_COLLECTION = 'NO_DATA_COLLECTION'
+    INVALID_DATA_COLLECTION_RESPONSE = 'INVALID_DATA_COLLECTION_RESPONSE'
+    NO_TASKS_FOUND = 'NO_TASKS_FOUND'
+    TARGET_SPEC_REQUIRED = 'TARGET_SPEC_REQUIRED'
+    TARGET_SPEC_NOT_FOUND = 'TARGET_SPEC_NOT_FOUND'
+    UNSUPPORTED_METHOD = 'UNSUPPORTED_METHOD'
+    ANNOTATING_DATA = 'ANNOTATING_DATA'
+    CRITICAL_ERROR = 'CRITICAL_ERROR'
+    TASK_PROCESSING_FAILED = 'TASK_PROCESSING_FAILED'
+    ANNOTATION_COMPLETED = 'ANNOTATION_COMPLETED'
+    INVALID_TASK_RESPONSE = 'INVALID_TASK_RESPONSE'
+    TARGET_SPEC_REQUIRED_FOR_TASK = 'TARGET_SPEC_REQUIRED_FOR_TASK'
+    UNSUPPORTED_METHOD_FOR_TASK = 'UNSUPPORTED_METHOD_FOR_TASK'
+    PRIMARY_IMAGE_URL_NOT_FOUND = 'PRIMARY_IMAGE_URL_NOT_FOUND'
+    FILE_SPEC_NOT_FOUND = 'FILE_SPEC_NOT_FOUND'
+    FILE_ORIGINAL_NAME_NOT_FOUND = 'FILE_ORIGINAL_NAME_NOT_FOUND'
+    URL_NOT_FOUND = 'URL_NOT_FOUND'
+    FETCH_DATA_FAILED = 'FETCH_DATA_FAILED'
+    CONVERT_DATA_FAILED = 'CONVERT_DATA_FAILED'
+    PREPROCESSOR_ID_REQUIRED = 'PREPROCESSOR_ID_REQUIRED'
+    INFERENCE_PROCESSING_FAILED = 'INFERENCE_PROCESSING_FAILED'
+    ANNOTATING_INFERENCE_DATA = 'ANNOTATING_INFERENCE_DATA'
+    INFERENCE_ANNOTATION_COMPLETED = 'INFERENCE_ANNOTATION_COMPLETED'
+    INFERENCE_PREPROCESSOR_FAILED = 'INFERENCE_PREPROCESSOR_FAILED'
+
+    # Orchestrator workflow codes
+    TO_TASK_STARTED = 'TO_TASK_STARTED'
+    TO_TASK_COMPLETED = 'TO_TASK_COMPLETED'
+    TO_TASK_FAILED = 'TO_TASK_FAILED'
+    STEP_STARTED = 'STEP_STARTED'
+    STEP_COMPLETED = 'STEP_COMPLETED'
+    STEP_FAILED = 'STEP_FAILED'
+    ROLLBACK_FAILED = 'ROLLBACK_FAILED'
+    ROLLBACK_ACTION_FAILED = 'ROLLBACK_ACTION_FAILED'
+
+    # Additional strategy codes
+    VALIDATION_FAILED = 'VALIDATION_FAILED'
+    NO_DATA_UNIT = 'NO_DATA_UNIT'
+    NO_DATA_UNIT_FILES = 'NO_DATA_UNIT_FILES'
+    TARGET_SPEC_URL_NOT_FOUND = 'TARGET_SPEC_URL_NOT_FOUND'
+    DATA_DOWNLOAD_FAILED = 'DATA_DOWNLOAD_FAILED'
+    JSON_DECODE_FAILED = 'JSON_DECODE_FAILED'
+    ANNOTATION_SUBMISSION_FAILED = 'ANNOTATION_SUBMISSION_FAILED'
+    NO_PREPROCESSOR_ID = 'NO_PREPROCESSOR_ID'
+    DATA_EXTRACTION_FAILED = 'DATA_EXTRACTION_FAILED'
+    PROGRESS_UPDATE_FAILED = 'PROGRESS_UPDATE_FAILED'
+    METRICS_RECORDING_FAILED = 'METRICS_RECORDING_FAILED'
+    METRICS_UPDATE_FAILED = 'METRICS_UPDATE_FAILED'
+    METRICS_FINALIZATION_FAILED = 'METRICS_FINALIZATION_FAILED'
+
+
+LOG_MESSAGES = {
+    LogCode.INVALID_PROJECT_RESPONSE: {
+        'message': 'Invalid project response received.',
+        'level': Context.DANGER,
+    },
+    LogCode.NO_DATA_COLLECTION: {
+        'message': 'Project does not have a data collection.',
+        'level': Context.DANGER,
+    },
+    LogCode.INVALID_DATA_COLLECTION_RESPONSE: {
+        'message': 'Invalid data collection response received.',
+        'level': Context.DANGER,
+    },
+    LogCode.NO_TASKS_FOUND: {
+        'message': 'Tasks to annotate not found.',
+        'level': Context.WARNING,
+    },
+    LogCode.TARGET_SPEC_REQUIRED: {
+        'message': 'Target specification name is required for file annotation method.',
+        'level': Context.DANGER,
+    },
+    LogCode.TARGET_SPEC_NOT_FOUND: {
+        'message': 'Target specification name "{}" not found in file specifications',
+        'level': Context.DANGER,
+    },
+    LogCode.UNSUPPORTED_METHOD: {
+        'message': 'Unsupported annotation method: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.ANNOTATING_DATA: {
+        'message': 'Annotating data to tasks...',
+        'level': None,
+    },
+    LogCode.CRITICAL_ERROR: {
+        'message': 'Critical error occured while processing task. Stopping the job.',
+        'level': Context.DANGER,
+    },
+    LogCode.TASK_PROCESSING_FAILED: {
+        'message': 'Failed to process task {}: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.ANNOTATION_COMPLETED: {
+        'message': 'Annotation completed. Success: {}, Failed: {}',
+        'level': None,
+    },
+    LogCode.INVALID_TASK_RESPONSE: {
+        'message': 'Invalid task response received for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.TARGET_SPEC_REQUIRED_FOR_TASK: {
+        'message': 'Target specification name is required for file annotation method for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.UNSUPPORTED_METHOD_FOR_TASK: {
+        'message': 'Unsupported annotation method: {} for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.PRIMARY_IMAGE_URL_NOT_FOUND: {
+        'message': 'Primary image URL not found in task data for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.FILE_SPEC_NOT_FOUND: {
+        'message': 'File specification not found for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.FILE_ORIGINAL_NAME_NOT_FOUND: {
+        'message': 'File original name not found for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.URL_NOT_FOUND: {
+        'message': 'URL not found for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.FETCH_DATA_FAILED: {
+        'message': 'Failed to fetch data from URL: {} for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.CONVERT_DATA_FAILED: {
+        'message': 'Failed to convert data to task object: {} for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.PREPROCESSOR_ID_REQUIRED: {
+        'message': 'Pre-processor ID is required for inference annotation method for task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.INFERENCE_PROCESSING_FAILED: {
+        'message': 'Failed to process inference for task {}: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.ANNOTATING_INFERENCE_DATA: {
+        'message': 'Annotating data to tasks using inference...',
+        'level': None,
+    },
+    LogCode.INFERENCE_ANNOTATION_COMPLETED: {
+        'message': 'Inference annotation completed. Success: {}, Failed: {}',
+        'level': None,
+    },
+    LogCode.INFERENCE_PREPROCESSOR_FAILED: {
+        'message': 'Inference pre processor failed for task {}: {}',
+        'level': Context.DANGER,
+    },
+    # Orchestrator workflow messages
+    LogCode.TO_TASK_STARTED: {
+        'message': 'ToTask action started.',
+        'level': Context.INFO,
+    },
+    LogCode.TO_TASK_COMPLETED: {
+        'message': 'ToTask action completed successfully.',
+        'level': Context.SUCCESS,
+    },
+    LogCode.TO_TASK_FAILED: {
+        'message': 'ToTask action failed: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.STEP_STARTED: {
+        'message': 'Starting workflow step: {}',
+        'level': Context.INFO,
+    },
+    LogCode.STEP_COMPLETED: {
+        'message': 'Completed workflow step: {}',
+        'level': Context.INFO,
+    },
+    LogCode.STEP_FAILED: {
+        'message': 'Failed workflow step {}: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.ROLLBACK_FAILED: {
+        'message': 'Failed to rollback step {}: {}',
+        'level': Context.WARNING,
+    },
+    LogCode.ROLLBACK_ACTION_FAILED: {
+        'message': 'Failed to execute rollback action: {}',
+        'level': Context.WARNING,
+    },
+    # Additional strategy messages
+    LogCode.VALIDATION_FAILED: {
+        'message': 'Validation failed: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.NO_DATA_UNIT: {
+        'message': 'Task does not have a data unit',
+        'level': Context.DANGER,
+    },
+    LogCode.NO_DATA_UNIT_FILES: {
+        'message': 'Data unit does not have files',
+        'level': Context.DANGER,
+    },
+    LogCode.TARGET_SPEC_URL_NOT_FOUND: {
+        'message': 'Target specification URL not found for {} in task {}',
+        'level': Context.DANGER,
+    },
+    LogCode.DATA_DOWNLOAD_FAILED: {
+        'message': 'Failed to download data for task {}: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.JSON_DECODE_FAILED: {
+        'message': 'Failed to decode JSON data for task {}: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.ANNOTATION_SUBMISSION_FAILED: {
+        'message': 'Failed to submit annotation data for task {}: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.NO_PREPROCESSOR_ID: {
+        'message': 'Pre-processor ID is required for inference annotation method',
+        'level': Context.DANGER,
+    },
+    LogCode.DATA_EXTRACTION_FAILED: {
+        'message': 'Data extraction failed: {}',
+        'level': Context.DANGER,
+    },
+    LogCode.PROGRESS_UPDATE_FAILED: {
+        'message': 'Progress update failed: {}',
+        'level': Context.WARNING,
+    },
+    LogCode.METRICS_RECORDING_FAILED: {
+        'message': 'Metrics recording failed: {}',
+        'level': Context.WARNING,
+    },
+    LogCode.METRICS_UPDATE_FAILED: {
+        'message': 'Metrics update failed: {}',
+        'level': Context.WARNING,
+    },
+    LogCode.METRICS_FINALIZATION_FAILED: {
+        'message': 'Metrics finalization failed: {}',
+        'level': Context.WARNING,
+    },
+}

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)