synapse-sdk 1.0.0b18__py3-none-any.whl → 1.0.0b20__py3-none-any.whl

synapse_sdk/plugins/categories/export/templates/plugin/export.py

@@ -1,197 +1,63 @@
-import json
-from itertools import tee
 from pathlib import Path
+from typing import Generator
 
-import requests
+from . import BaseExporter
 
-from synapse_sdk.plugins.categories.export.enums import ExportStatus
 
+class Exporter(BaseExporter):
+    """Plugin export action interface for organizing files.
 
-def export(run, export_items, path_root, **params):
-    """Executes the export task.
-
-    Args:
-        run : Execution object
-        export_items (generator):
-            - data (dict): dm_schema_data information.
-            - files (dict): File information. Includes file URL, original file path, metadata, etc.
-            - id (int): ground_truth ID
-        path_root : pathlib object, the path to export
-        **params: Additional parameters
-
-    Returns:
-        dict: Result
-    """
-
-    export_path = path_root / params['name']
-    unique_export_path = export_path
-    counter = 1
-    while unique_export_path.exists():
-        unique_export_path = export_path.with_name(f'{export_path.name}({counter})')
-        counter += 1
-    unique_export_path.mkdir(parents=True)
-
-    run.log_message('Starting export process.')
-
-    # results contains all information fetched through the list API.
-    # example:
-    #   params.get('results', [])
-
-    save_original_file_flag = params.get('save_original_file')
-    errors_json_file_list = []
-    errors_original_file_list = []
-
-    # Path to save JSON files
-    json_output_path = unique_export_path / 'json'
-    json_output_path.mkdir(parents=True, exist_ok=True)
-
-    # Path to save original files
-    if save_original_file_flag:
-        origin_files_output_path = unique_export_path / 'origin_files'
-        origin_files_output_path.mkdir(parents=True, exist_ok=True)
-
-    export_items_count, export_items_process = tee(export_items)
-    total = sum(1 for _ in export_items_count)
-
-    original_file_metrics_record = run.MetricsRecord(stand_by=total, success=0, failed=0)
-    data_file_metrics_record = run.MetricsRecord(stand_by=total, success=0, failed=0)
-    # progress init
-    run.set_progress(0, total, category='dataset_conversion')
-    for no, export_item in enumerate(export_items_process, start=1):
-        run.set_progress(no, total, category='dataset_conversion')
-        if no == 1:
-            run.log_message('Converting dataset.')
-        preprocessed_data = before_convert(export_item)
-        converted_data = convert_data(preprocessed_data)
-        final_data = after_convert(converted_data)
-
-        # Call if original file extraction is needed
-        if save_original_file_flag:
-            if no == 1:
-                run.log_message('Saving original file.')
-            original_status = save_original_file(run, final_data, origin_files_output_path, errors_original_file_list)
-
-            original_file_metrics_record.stand_by -= 1
-            if original_status == ExportStatus.FAILED:
-                original_file_metrics_record.failed += 1
-                continue
-            else:
-                original_file_metrics_record.success += 1
-
-        run.log_metrics(record=original_file_metrics_record, category='original_file')
-
-        # Extract data as JSON files
-        if no == 1:
-            run.log_message('Saving json file.')
-        data_status = save_as_json(run, final_data, json_output_path, errors_json_file_list)
-
-        data_file_metrics_record.stand_by -= 1
-        if data_status == ExportStatus.FAILED:
-            data_file_metrics_record.failed += 1
-            continue
-        else:
-            data_file_metrics_record.success += 1
-
-        run.log_metrics(record=data_file_metrics_record, category='data_file')
-
-    run.end_log()
-
-    # Save error list files
-    if len(errors_json_file_list) > 0 or len(errors_original_file_list) > 0:
-        export_error_file = {'json_file_name': errors_json_file_list, 'origin_file_name': errors_original_file_list}
-        with (unique_export_path / 'error_file_list.json').open('w', encoding='utf-8') as f:
-            json.dump(export_error_file, f, indent=4, ensure_ascii=False)
-
-    return {'export_path': str(path_root)}
-
-
-def convert_data(data):
-    """Converts the data."""
-    return data
-
-
-def before_convert(data):
-    """Preprocesses the data before conversion."""
-    return data
-
-
-def after_convert(data):
-    """Post-processes the data after conversion."""
-    return data
-
-
-def get_original_file_name(files):
-    """Retrieve the original file path from the given file information.
-
-    Args:
-        files (dict): A dictionary containing file information, including file URL,
-                      original file path, metadata, etc.
-
-    Returns:
-        file_name (str): The original file name extracted from the file information.
+    This class provides a minimal interface for plugin developers to implement
+    their own export logic.
     """
-    return files['file_name_original']
-
-
-def save_original_file(run, result, base_path, error_file_list):
-    """Saves the original file.
-
-    Args:
-        run : Execution object
-        result (dict): API response data containing file information.
-        base_path (Path): The directory where the file will be saved.
-        error_file_list (list): A list to store error files.
-    """
-    file_url = result['files']['url']
-    file_name = get_original_file_name(result['files'])
-    response = requests.get(file_url)
-    file_info = {'file_name': file_name}
-    error_msg = ''
-    try:
-        with (base_path / file_name).open('wb') as file:
-            file.write(response.content)
-        status = ExportStatus.SUCCESS
-    except Exception as e:
-        error_msg = str(e)
-        error_file_list.append([file_name, error_msg])
-        status = ExportStatus.FAILED
-
-    run.export_log_original_file(result['id'], file_info, status, error_msg)
-    return status
-
-
-def save_as_json(run, result, base_path, error_file_list):
-    """Saves the data as a JSON file.
-
-    Args:
-        run : Execution object
-        result (dict): API response data containing file information.
-        base_path (Path): The directory where the file will be saved.
-        error_file_list (list): A list to store error files.
-    """
-    # Default save file name: original file name
-    file_name = Path(get_original_file_name(result['files'])).stem
-    json_data = result['data']
-    file_info = {'file_name': f'{file_name}.json'}
-
-    if json_data is None:
-        error_msg = 'data is Null'
-        error_file_list.append([f'{file_name}.json', error_msg])
-        status = ExportStatus.FAILED
-        run.log_export_event('NULL_DATA_DETECTED', result['id'])
-        run.export_log_json_file(result['id'], file_info, status, error_msg)
-
-        return status
-
-    error_msg = ''
-    try:
-        with (base_path / f'{file_name}.json').open('w', encoding='utf-8') as f:
-            json.dump(json_data, f, indent=4, ensure_ascii=False)
-        status = ExportStatus.SUCCESS
-    except Exception as e:
-        error_msg = str(e)
-        error_file_list.append([f'{file_name}.json', str(e)])
-        status = ExportStatus.FAILED
 
-    run.export_log_json_file(result['id'], file_info, status, error_msg)
-    return status
+    def __init__(self, run, export_items: Generator, path_root: Path, **params):
+        """Initialize the plugin export action class.
+        Args:
+            run: Plugin run object with logging capabilities.
+            export_items (generator):
+                - data (dict): dm_schema_data information.
+                - files (dict): File information. Includes file URL, original file path, metadata, etc.
+                - id (int): target ID (ex. assignment id, task id, ground_truth_event id)
+            path_root: pathlib object, the path to export
+            **params: Additional parameters
+                - name (str): The name of the action.
+                - description (str | None): The description of the action.
+                - storage (int): The storage ID to save the exported data.
+                - save_original_file (bool): Whether to save the original file.
+                - path (str): The path to save the exported data.
+                - target (str): The target source to export data from. (ex. ground_truth, assignment, task)
+                - filter (dict): The filter criteria to apply.
+                - extra_params (dict | None): Additional parameters for export customization.
+                    Example: {"include_metadata": True, "compression": "gzip"}
+                - count (int): Total number of results.
+                - results (list): List of results fetched through the list API.
+                - project_id (int): Project ID.
+                - configuration (dict): Project configuration.
+        """
+        super().__init__(run, export_items, path_root, **params)
+
+    def export(self, export_items=None, results=None, **kwargs) -> dict:
+        """Executes the export task using the base class implementation.
+
+        Args:
+            export_items: Optional export items to process. If not provided, uses self.export_items.
+            results: Optional results data to process alongside export_items.
+            **kwargs: Additional parameters for export customization.
+
+        Returns:
+            dict: Result
+        """
+        return super().export(export_items, results, **kwargs)
+
+    def convert_data(self, data):
+        """Converts the data."""
+        return data
+
+    def before_convert(self, data):
+        """Preprocesses the data before conversion."""
+        return data
+
+    def after_convert(self, data):
+        """Post-processes the data after conversion."""
+        return data

synapse_sdk/plugins/categories/upload/actions/upload.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import os
 import shutil
@@ -5,7 +6,7 @@ from datetime import datetime
 from enum import Enum
 from io import BytesIO
 from pathlib import Path
-from typing import Annotated, Any, Dict, List, Optional
+from typing import Annotated, Any, Awaitable, Dict, List, Optional, TypeVar
 
 from openpyxl import load_workbook
 from openpyxl.utils.exceptions import InvalidFileException
@@ -25,6 +26,9 @@ from synapse_sdk.shared.enums import Context
 from synapse_sdk.utils.pydantic.validators import non_blank
 from synapse_sdk.utils.storage import get_pathlib
 
+# Type variable for generic async return type
+T = TypeVar('T')
+
 
 class PathAwareJSONEncoder(json.JSONEncoder):
     """Custom JSON encoder that handles Path-like objects."""
@@ -178,7 +182,7 @@ class UploadRun(Run):
         },
         # Debug information - only for EventLog
         'EXCEL_FILE_VALIDATION_STARTED': {
-            'message': 'Excel file validation started: {}',
+            'message': 'Excel file validation started',
             'level': Context.INFO,
         },
         'EXCEL_WORKBOOK_LOADED': {
@@ -186,7 +190,7 @@ class UploadRun(Run):
             'level': Context.INFO,
         },
         'FILE_ORGANIZATION_STARTED': {
-            'message': 'File organization started for directory: {}',
+            'message': 'File organization started',
             'level': Context.INFO,
         },
         'BATCH_PROCESSING_STARTED': {
@@ -202,7 +206,7 @@ class UploadRun(Run):
             'level': Context.INFO,
         },
         'EXCEL_FILE_NOT_FOUND_PATH': {
-            'message': 'Excel metadata file not found: {}',
+            'message': 'Excel metadata file not found',
             'level': Context.WARNING,
         },
         'EXCEL_SECURITY_VALIDATION_FAILED': {
@@ -394,6 +398,9 @@ class ExcelMetadataUtils:
 class UploadParams(BaseModel):
     """Upload action parameters.
 
+    This class defines all configuration parameters for the upload action, including
+    advanced asynchronous upload capabilities for improved performance.
+
     Args:
         name (str): The name of the action.
         description (str | None): The description of the action.
@@ -405,6 +412,17 @@ class UploadParams(BaseModel):
         excel_metadata_path (str | None): Path to excel file containing metadata.
             Defaults to 'meta.xlsx' or 'meta.xls' in the path directory.
         is_recursive (bool): Enable recursive file discovery in subdirectories. Defaults to False.
+        use_async_upload (bool): Enable asynchronous upload data file processing for improved performance.
+            Defaults to True.
+        max_file_size_mb (int): The maximum file size not using chunked_upload in MB. Defaults to 50MB.
+        creating_data_unit_batch_size (int): The batch size for creating data units. Defaults to 100.
+        extra_params (dict | None): Extra parameters for the action.
+            Example: {"include_metadata": True, "compression": "gzip"}
+
+    Note:
+        Async upload requires plugin developers to implement handle_upload_files_async()
+        method for maximum benefit. Default implementation provides compatibility
+        but limited performance improvement.
     """
 
     name: Annotated[str, AfterValidator(non_blank)]
@@ -416,7 +434,9 @@ class UploadParams(BaseModel):
     excel_metadata_path: str | None = None
     is_recursive: bool = False
     max_file_size_mb: int = 50
-    creating_data_unit_batch_size: int = 100
+    creating_data_unit_batch_size: int = 1
+    use_async_upload: bool = True
+    extra_params: dict | None = None
 
     @field_validator('storage', mode='before')
     @classmethod
@@ -540,8 +560,6 @@ class UploadAction(Action):
         analyze_collection: The progress category for the analyze collection process.
         data_file_upload: The progress category for the upload process.
         generate_data_units: The progress category for the generate data units process.
-        generate_tasks: The progress category for the generate tasks process.
-        generate_ground_truths: The progress category for the generate ground truths process.
 
     Metrics Categories:
         data_file: The metrics category for the data file.
@@ -581,9 +599,11 @@ class UploadAction(Action):
         self.excel_config = ExcelSecurityConfig()
         self.excel_utils = ExcelMetadataUtils(self.excel_config)
 
-    def get_uploader(self, path, file_specification, organized_files):
+    def get_uploader(self, path, file_specification, organized_files, params: Dict = None):
         """Get uploader from entrypoint."""
-        return self.entrypoint(self.run, path, file_specification, organized_files)
+        return self.entrypoint(
+            self.run, path, file_specification, organized_files, extra_params=params.get('extra_params')
+        )
 
     def _discover_files_recursive(self, dir_path: Path) -> List[Path]:
         """Discover files recursively in a directory."""
@@ -797,10 +817,11 @@ class UploadAction(Action):
         excel_path = None
 
         # Check if user provided a specific excel_metadata_path
-        if self.params.get('excel_metadata_path'):
-            excel_path = pathlib_cwd / self.params['excel_metadata_path']
+        excel_metadata_path = self.params.get('excel_metadata_path')
+        if excel_metadata_path:
+            excel_path = pathlib_cwd / excel_metadata_path
             if not excel_path.exists():
-                self.run.log_message_with_code('EXCEL_FILE_NOT_FOUND_PATH', str(excel_path))
+                self.run.log_message_with_code('EXCEL_FILE_NOT_FOUND_PATH')
                 return {}
         else:
             # Look for default meta.xlsx or meta.xls
@@ -810,7 +831,7 @@ class UploadAction(Action):
                 return {}
 
         try:
-            self.run.log_message_with_code('EXCEL_FILE_VALIDATION_STARTED', str(excel_path))
+            self.run.log_message_with_code('EXCEL_FILE_VALIDATION_STARTED')
 
             # Prepare Excel file with security validation
             excel_stream = self._prepare_excel_file(excel_path)
@@ -852,8 +873,15 @@ class UploadAction(Action):
         result: Dict[str, Any] = {}
 
         # Setup path object with path and storage.
-        storage = self.client.get_storage(self.params['storage'])
-        pathlib_cwd = get_pathlib(storage, self.params['path'])
+        storage_id = self.params.get('storage')
+        if storage_id is None:
+            raise ActionError('Storage parameter is required')
+        storage = self.client.get_storage(storage_id)
+
+        path = self.params.get('path')
+        if path is None:
+            raise ActionError('Path parameter is required')
+        pathlib_cwd = get_pathlib(storage, path)
 
         # Read excel metadata if configured or default file exists
         excel_metadata: Dict[str, Dict[str, Any]] = {}
@@ -881,7 +909,7 @@ class UploadAction(Action):
         organized_files = self._organize_files(pathlib_cwd, file_specification_template, excel_metadata)
 
         # Initialize uploader.
-        uploader = self.get_uploader(pathlib_cwd, file_specification_template, organized_files)
+        uploader = self.get_uploader(pathlib_cwd, file_specification_template, organized_files, self.params)
 
         # Get organized files from the uploader (plugin developer's custom implementation)
         # or use the default organization method if uploader doesn't provide valid files
@@ -896,7 +924,11 @@ class UploadAction(Action):
         if not organized_files:
             self.run.log_message_with_code('NO_FILES_FOUND')
             raise ActionError('Upload is aborted due to missing files.')
-        uploaded_files = self._upload_files(organized_files)
+        # Choose upload method based on async parameter
+        if self.params.get('use_async_upload', True):
+            uploaded_files = self.run_async(self._upload_files_async(organized_files, 10))
+        else:
+            uploaded_files = self._upload_files(organized_files)
         result['uploaded_files_count'] = len(uploaded_files)
 
         # Generate data units for the uploaded data.
@@ -904,7 +936,7 @@ class UploadAction(Action):
             self.run.log_message_with_code('NO_FILES_UPLOADED')
             raise ActionError('Upload is aborted due to no uploaded files.')
         generated_data_units = self._generate_data_units(
-            uploaded_files, self.params.get('creating_data_unit_batch_size')
+            uploaded_files, self.params.get('creating_data_unit_batch_size', 1)
         )
         result['generated_data_units_count'] = len(generated_data_units)
 
@@ -929,7 +961,9 @@ class UploadAction(Action):
         # Initialize progress
         self.run.set_progress(0, 2, category='analyze_collection')
 
-        collection_id = self.params['data_collection']
+        collection_id = self.params.get('data_collection')
+        if collection_id is None:
+            raise ActionError('Data collection parameter is required')
         self.run.set_progress(1, 2, category='analyze_collection')
 
         collection = self.run.client.get_data_collection(collection_id)
@@ -949,7 +983,9 @@ class UploadAction(Action):
         self.run.log_message_with_code('UPLOADING_DATA_FILES')
 
         client = self.run.client
-        collection_id = self.params['data_collection']
+        collection_id = self.params.get('data_collection')
+        if collection_id is None:
+            raise ActionError('Data collection parameter is required')
         upload_result = []
         current_progress = 0
         success_count = 0
@@ -980,6 +1016,129 @@ class UploadAction(Action):
 
         return upload_result
 
+    def run_async(self, coro: Awaitable[T]) -> T:
+        """Run async coroutine safely using asyncio.run().
+
+        This method properly manages event loop lifecycle and prevents
+        resource exhaustion from repeated event loop creation.
+
+        Args:
+            coro: The coroutine to execute
+
+        Returns:
+            The result of the coroutine execution
+
+        Raises:
+            RuntimeError: If called from within an existing event loop
+        """
+        import concurrent.futures
+
+        def _run_in_thread():
+            """Run the coroutine in a separate thread to avoid event loop conflicts."""
+            return asyncio.run(coro)
+
+        # Check if we're already in an event loop
+        try:
+            # If this doesn't raise, we're in an event loop
+            asyncio.get_running_loop()
+            # Run in thread pool to avoid "RuntimeError: cannot be called from a running event loop"
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(_run_in_thread)
+                return future.result()
+        except RuntimeError:
+            # No event loop running, safe to use asyncio.run directly
+            return asyncio.run(coro)
+
+    async def _upload_files_async(
+        self, organized_files: List[Dict[str, Any]], max_concurrent: int = 10
+    ) -> List[Dict[str, Any]]:
+        """Upload files to synapse-backend asynchronously with concurrency control."""
+        # Initialize progress
+        organized_files_count = len(organized_files)
+        self.run.set_progress(0, organized_files_count, category='upload_data_files')
+        self.run.log_message_with_code('UPLOADING_DATA_FILES')
+
+        client = self.run.client
+        collection_id = self.params.get('data_collection')
+        if collection_id is None:
+            raise ActionError('Data collection parameter is required')
+        upload_result = []
+        success_count = 0
+        failed_count = 0
+
+        # Initialize metrics
+        self._update_metrics(organized_files_count, success_count, failed_count, 'data_files')
+
+        # Control concurrency with semaphore
+        semaphore = asyncio.Semaphore(max_concurrent)
+
+        async def upload_single_file(organized_file):
+            async with semaphore:
+                loop = asyncio.get_event_loop()
+                try:
+                    # Determine if chunked upload should be used based on file size
+                    use_chunked_upload = self._requires_chunked_upload(organized_file)
+                    # Run sync upload_data_file in thread pool
+                    uploaded_data_file = await loop.run_in_executor(
+                        None, lambda: client.upload_data_file(organized_file, collection_id, use_chunked_upload)
+                    )
+                    self.run.log_data_file(organized_file, UploadStatus.SUCCESS)
+                    return {'status': 'success', 'result': uploaded_data_file}
+                except ClientError as e:
+                    # Handle API client errors (network, authentication, server errors)
+                    self.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.run.log_message_with_code('FILE_UPLOAD_FAILED', f'Client error: {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'client_error', 'retryable': True}
+                except (OSError, IOError) as e:
+                    # Handle file system errors (file not found, permissions, disk full)
+                    self.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.run.log_message_with_code('FILE_UPLOAD_FAILED', f'File system error: {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'file_error', 'retryable': False}
+                except MemoryError as e:
+                    # Handle out of memory errors (large files)
+                    self.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.run.log_message_with_code('FILE_UPLOAD_FAILED', f'Memory error (file too large): {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'memory_error', 'retryable': False}
+                except asyncio.TimeoutError as e:
+                    # Handle timeout errors (slow network, large files)
+                    self.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.run.log_message_with_code('FILE_UPLOAD_FAILED', f'Upload timeout: {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'timeout_error', 'retryable': True}
+                except ValueError as e:
+                    # Handle data validation errors (invalid file format, metadata issues)
+                    self.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.run.log_message_with_code('FILE_UPLOAD_FAILED', f'Data validation error: {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'validation_error', 'retryable': False}
+                except Exception as e:
+                    # Handle any remaining unexpected errors
+                    self.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.run.log_message_with_code('FILE_UPLOAD_FAILED', f'Unexpected error: {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'unknown_error', 'retryable': False}
+
+        # Create tasks for all files
+        tasks = [upload_single_file(organized_file) for organized_file in organized_files]
+
+        # Process files with progress updates
+        current_progress = 0
+        for completed_task in asyncio.as_completed(tasks):
+            result = await completed_task
+            current_progress += 1
+
+            if result['status'] == 'success':
+                success_count += 1
+                upload_result.append(result['result'])
+            else:
+                failed_count += 1
+
+            # Update metrics and progress
+            self._update_metrics(organized_files_count, success_count, failed_count, 'data_files')
+            self.run.set_progress(current_progress, organized_files_count, category='upload_data_files')
+
+        # Finish progress
+        self.run.set_progress(organized_files_count, organized_files_count, category='upload_data_files')
+
+        return upload_result
+
     def _generate_data_units(self, uploaded_files: List[Dict[str, Any]], batch_size: int) -> List[Dict[str, Any]]:
         """Generate data units for the uploaded data.
 
@@ -1073,14 +1232,14 @@ class UploadAction(Action):
             return organized_files
 
         self.run.log_message_with_code('TYPE_STRUCTURE_DETECTED')
-        self.run.log_message_with_code('FILE_ORGANIZATION_STARTED', str(directory))
+        self.run.log_message_with_code('FILE_ORGANIZATION_STARTED')
 
         # Collect and process files in a single pass
         dataset_files = {}
         required_specs = [spec['name'] for spec in file_specification if spec.get('is_required', False)]
 
         # Get recursive setting from params
-        is_recursive = self.params.get('is_recursive', False)
+        is_recursive = self.params.get('is_recursive', True)
 
         # Process all files from all type directories
         for spec_name, dir_path in type_dirs.items():

synapse_sdk/plugins/categories/upload/templates/config.yaml

@@ -3,5 +3,27 @@ actions:
     entrypoint: plugin.upload.Uploader
     options:
     supported_data_type: image # A primary data type of synapse backend collection. (e.g. 'image', 'text', 'video', 'pcd', 'audio')
-    ui_schema: |
-      Dumped FormKit Schema for upload plugin custom options
+    ui_schema: # UI schema for the input of extra params
+      - $formkit: "radio"
+        name: "file_format"
+        label: "File Format"
+        help: "Select the file format for upload processing"
+        required: false
+        value: "original"
+        options:
+          - label: "Keep Original"
+            value: "original"
+          - label: "Convert to JPEG"
+            value: "jpeg"
+          - label: "Convert to PNG"
+            value: "png"
+      - $formkit: "checkbox"
+        name: "include_metadata"
+        label: "Include Metadata"
+        help: "Include file metadata during upload"
+        value: true
+      - $formkit: "text"
+        name: "custom_tag"
+        label: "Custom Tag"
+        help: "Add a custom tag to uploaded files"
+        placeholder: "Enter custom tag"

synapse_sdk/plugins/categories/upload/templates/plugin/upload.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import List
+from typing import Dict, List
 
 
 class Uploader:
@@ -9,7 +9,9 @@ class Uploader:
     their own file organization logic.
     """
 
-    def __init__(self, run, path: Path, file_specification: List = None, organized_files: List = None):
+    def __init__(
+        self, run, path: Path, file_specification: List = None, organized_files: List = None, extra_params: Dict = None
+    ):
         """Initialize the plugin upload action class.
 
         Args:
@@ -17,11 +19,15 @@ class Uploader:
             path: Path object pointing to the upload target directory.
             file_specification: List of specifications that define the structure of files to be uploaded.
                 Each specification contains details like file name, type, and requirements.
+            organized_files: List of pre-organized files based on the default logic.
+                Each item is a dictionary with 'files' and 'meta' keys.
+            extra_params: Additional parameters for customization.
         """
         self.run = run
         self.path = path
         self.file_specification = file_specification
         self.organized_files = organized_files
+        self.extra_params = extra_params
 
     def handle_upload_files(self) -> List:
         """Customize the organization of files for upload.