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

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

@@ -1,14 +1,53 @@
-from pathlib import Path
 from typing import Annotated
 
-from pydantic import AfterValidator, BaseModel, ValidationInfo, field_validator
+from pydantic import AfterValidator, BaseModel, ValidationInfo, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 from synapse_sdk.clients.exceptions import ClientError
 from synapse_sdk.utils.pydantic.validators import non_blank
-from synapse_sdk.utils.storage import get_pathlib
 
-from .utils import ExcelSecurityConfig
+
+class ExcelMetadataFile(BaseModel):
+    """Excel metadata configuration for base64 encoded data.
+
+    This model is used specifically for base64-encoded Excel metadata files,
+    typically from web frontends or API integrations.
+
+    Attributes:
+        data: Base64 encoded content of the Excel file
+        filename: Name of the original file before base64 encoding
+
+    Examples:
+        Base64 mode:
+            >>> config = ExcelMetadataFile(
+            ...     data="UEsDBBQABgAI...",
+            ...     filename="metadata.xlsx"
+            ... )
+    """
+
+    data: str
+    filename: str
+
+
+class AssetConfig(BaseModel):
+    """Configuration for individual asset in multi-path mode.
+
+    Used when use_single_path=False to specify unique paths
+    and recursive settings for each file specification.
+
+    Attributes:
+        path (str): File system path for this specific asset
+        is_recursive (bool): Whether to recursively search subdirectories for this asset
+
+    Example:
+        >>> asset_config = AssetConfig(
+        ...     path="/sensors/camera/front",
+        ...     is_recursive=True
+        ... )
+    """
+
+    path: str
+    is_recursive: bool = True
 
 
 class UploadParams(BaseModel):
@@ -18,45 +57,93 @@ class UploadParams(BaseModel):
     Uses Pydantic for type validation and custom validators to ensure
     storage, data_collection, and project resources exist before processing.
 
+    Supports two modes controlled by use_single_path flag:
+
+    1. Single Path Mode (use_single_path=True, DEFAULT):
+       Traditional mode - all file specifications share one base path.
+       Requires: path, is_recursive
+       Ignores: assets
+
+    2. Multi-Path Mode (use_single_path=False):
+       Advanced mode - each file specification has its own path.
+       Requires: assets (dict with file spec names as keys)
+       Ignores: path, is_recursive
+
     Attributes:
         name (str): Human-readable name for the upload operation
         description (str | None): Optional description of the upload
-        path (str): File system path to upload from
+        use_single_path (bool): Mode selector (True=single path, False=multi-path)
+        path (str | None): Base path for single path mode
+        is_recursive (bool): Global recursive setting for single path mode
+        assets (dict[str, AssetConfig] | None): Per-asset configs for multi-path mode
         storage (int): Storage ID where files will be uploaded
-        data_collection (int): Data data_collection ID for organizing uploads
+        data_collection (int): Data collection ID for organizing uploads
         project (int | None): Optional project ID for grouping
-        excel_metadata_path (str | None): Path to Excel metadata file
-        is_recursive (bool): Whether to recursively process subdirectories
+        excel_metadata_path (str | None): Path to Excel metadata file (traditional, backward compatible)
+            Note: This parameter will be deprecated in a future version. Consider using excel_metadata instead.
+        excel_metadata (ExcelMetadataFile | None): Base64 encoded Excel metadata (for web/API integration)
+            Note: Cannot use both excel_metadata_path and excel_metadata simultaneously
         max_file_size_mb (int): Maximum file size limit in megabytes
         creating_data_unit_batch_size (int): Batch size for data unit creation
         use_async_upload (bool): Whether to use asynchronous upload processing
-        extra_params (dict | None): Extra parameters for the action.
-            Example: {"include_metadata": True, "compression": "gzip"}
+        extra_params (dict | None): Extra parameters for the action
 
     Validation:
         - name: Must be non-blank after validation
         - storage: Must exist and be accessible via client API
         - data_collection: Must exist and be accessible via client API
         - project: Must exist if specified, or can be None
-        - excel_metadata_path: Must be valid Excel file if specified
-
-    Example:
-        >>> params = UploadParams(
-        ...     name="Data Upload",
-        ...     path="/data/files",
-        ...     storage=1,
-        ...     data_collection=5
-        ... )
+        - use_single_path mode: Validates required fields per mode
+
+    Examples:
+        Single Path Mode (Traditional):
+            >>> params = UploadParams(
+            ...     name="Standard Upload",
+            ...     use_single_path=True,
+            ...     path="/data/experiment_1",
+            ...     is_recursive=True,
+            ...     storage=1,
+            ...     data_collection=5
+            ... )
+
+        Multi-Path Mode (Advanced):
+            >>> params = UploadParams(
+            ...     name="Multi-Source Upload",
+            ...     use_single_path=False,
+            ...     assets={
+            ...         "image_1": AssetConfig(path="/sensors/camera", is_recursive=True),
+            ...         "pcd_1": AssetConfig(path="/sensors/lidar", is_recursive=False)
+            ...     },
+            ...     storage=1,
+            ...     data_collection=5
+            ... )
     """
 
     name: Annotated[str, AfterValidator(non_blank)]
     description: str | None = None
-    path: str
+
+    # Mode selector flag (True = single path mode, False = multi-path mode)
+    use_single_path: bool = True
+
+    # Single path mode fields (used when use_single_path=True)
+    path: str | None = None
+    is_recursive: bool = True
+
+    # Multi-path mode fields (used when use_single_path=False)
+    assets: dict[str, AssetConfig] | None = None
+
     storage: int
     data_collection: int
     project: int | None = None
+
+    # Excel metadata - two separate parameters for clarity:
+    # 1. excel_metadata_path: Simple file path string (backward compatible, traditional usage)
+    #    NOTE: Will be deprecated in a future version. Consider using excel_metadata instead.
+    # 2. excel_metadata: Dictionary with base64 encoded data (new, for web/API integration)
+    # TODO: Plan to deprecate excel_metadata_path in a few versions for backward compatibility
     excel_metadata_path: str | None = None
-    is_recursive: bool = True
+    excel_metadata: ExcelMetadataFile | None = None
+
     max_file_size_mb: int = 50
     creating_data_unit_batch_size: int = 1
     use_async_upload: bool = True
@@ -107,80 +194,33 @@ class UploadParams(BaseModel):
             raise PydanticCustomError('client_error', 'Error occurred while checking project exists.')
         return value
 
-    @field_validator('excel_metadata_path', mode='after')
-    @classmethod
-    def check_excel_metadata_path(cls, value, info: ValidationInfo) -> str | None:
-        if not value:
-            return value
-
-        # Validate file extension
-        if not value.lower().endswith(('.xlsx', '.xls')):
-            raise PydanticCustomError('invalid_file_type', 'Excel metadata file must be .xlsx or .xls format.')
-
-        # Get storage and path from validation data
-        if not (hasattr(info, 'data') and 'storage' in info.data and 'path' in info.data):
-            # If we don't have storage/path data yet, just validate extension
-            return value
-
-        if info.context is None:
-            raise PydanticCustomError('missing_context', 'Validation context is required.')
-
-        action = info.context['action']
-        client = action.client
-
-        try:
-            # Get storage configuration
-            storage_id = info.data['storage']
-            storage = client.get_storage(storage_id)
-
-            # Skip file system validation if storage doesn't have provider (likely test environment)
-            if not isinstance(storage, dict) or 'provider' not in storage:
-                # Basic validation only - likely in test environment
-                return value
-
-            # Get the actual file system path using storage + path
-            base_path = get_pathlib(storage, info.data['path'])
-
-            # Support both absolute and relative paths
-            if Path(value).is_absolute():
-                excel_path = Path(value)
-            else:
-                excel_path = base_path / value
-
-            if not excel_path.exists():
-                raise PydanticCustomError('file_not_found', 'Excel metadata file not found.')
-
-            # Validate file size
-            file_size = excel_path.stat().st_size
-            excel_config = ExcelSecurityConfig()
-            if file_size > excel_config.MAX_FILE_SIZE_BYTES:
-                max_size_mb = excel_config.MAX_FILE_SIZE_MB
+    @model_validator(mode='after')
+    def validate_path_configuration(self) -> 'UploadParams':
+        """Validate path configuration based on use_single_path mode."""
+        if self.use_single_path:
+            # Single path mode: requires path
+            if not self.path:
                 raise PydanticCustomError(
-                    'file_too_large',
-                    'Excel metadata file is too large. Maximum size is {max_size_mb}MB.',
-                    {'max_size_mb': max_size_mb},
+                    'missing_path', "When use_single_path=true (single path mode), 'path' is required"
                 )
+            # Warn if assets is provided in single path mode (it will be ignored)
+            # For now, we'll silently ignore it
+        else:
+            # Multi-path mode: requires assets
+            if not self.assets:
+                raise PydanticCustomError(
+                    'missing_assets',
+                    "When use_single_path=false (multi-path mode), 'assets' must be provided "
+                    'with path configurations for each file specification',
+                )
+            # path and is_recursive are ignored in multi-path mode
 
-            # Validate file format
-            try:
-                with open(excel_path, 'rb') as f:
-                    header = f.read(8)
-                    if not header:
-                        raise PydanticCustomError('invalid_file', 'Excel metadata file appears to be empty.')
-
-                    if excel_path.suffix.lower() == '.xlsx':
-                        if not header.startswith(b'PK'):
-                            raise PydanticCustomError('invalid_file', 'Excel metadata file appears to be corrupted.')
-                    elif excel_path.suffix.lower() == '.xls':
-                        if not (header.startswith(b'\xd0\xcf\x11\xe0') or header.startswith(b'\x09\x08')):
-                            raise PydanticCustomError('invalid_file', 'Excel metadata file appears to be corrupted.')
-
-            except (OSError, IOError):
-                raise PydanticCustomError('file_access_error', 'Cannot access Excel metadata file.')
-
-        except ClientError:
-            raise PydanticCustomError('client_error', 'Error occurred while checking storage.')
-        except Exception as e:
-            raise PydanticCustomError('validation_error', f'Error validating Excel metadata file: {str(e)}')
+        # Validate excel metadata parameters - cannot use both at the same time
+        if self.excel_metadata_path and self.excel_metadata:
+            raise PydanticCustomError(
+                'conflicting_excel_metadata',
+                "Cannot specify both 'excel_metadata_path' and 'excel_metadata'. "
+                "Use 'excel_metadata_path' for file paths or 'excel_metadata' for base64 encoded data.",
+            )
 
-        return value
+        return self

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

@@ -21,8 +21,8 @@ class CleanupStep(BaseStep):
     def execute(self, context: UploadContext) -> StepResult:
         """Execute cleanup step."""
         try:
-            # Cleanup temporary directory
-            self._cleanup_temp_directory(context)
+            # Cleanup temporary directory - commented out because duplicated process with ray cleanup process
+            # self._cleanup_temp_directory(context)
 
             # Log completion
             context.run.log_message_with_code(LogCode.IMPORT_COMPLETED)

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

@@ -1,8 +1,11 @@
+import base64
+import tempfile
 from pathlib import Path
 
 from ..context import StepResult, UploadContext
 from ..enums import LogCode
 from ..exceptions import ExcelParsingError, ExcelSecurityError
+from ..models import ExcelMetadataFile
 from .base import BaseStep
 
 
@@ -25,22 +28,36 @@ class ProcessMetadataStep(BaseStep):
             return self.create_success_result(data={'metadata': {}})
 
         excel_metadata = {}
+        temp_file_to_cleanup = None
 
         try:
-            # Check if Excel metadata path is specified
-            excel_metadata_path = context.get_param('excel_metadata_path')
-            if excel_metadata_path:
-                # Convert string to Path object
-                if isinstance(excel_metadata_path, str):
-                    excel_metadata_path = Path(excel_metadata_path)
-
-                if excel_metadata_path.exists() and excel_metadata_path.is_file():
-                    excel_path = excel_metadata_path
-                else:
-                    excel_path = context.pathlib_cwd / excel_metadata_path
-                if not excel_path.exists():
+            # Check if Excel metadata is specified - try both parameters
+            # TODO: Plan to deprecate excel_metadata_path in a few versions (backward compatibility)
+            excel_metadata_path_config = context.get_param('excel_metadata_path')
+            excel_metadata_config = context.get_param('excel_metadata')
+
+            if excel_metadata_path_config:
+                # Traditional path-based approach (will be deprecated in future)
+                excel_path, is_temp = self._resolve_excel_path_from_string(excel_metadata_path_config, context)
+
+                if not excel_path or not excel_path.exists():
                     context.run.log_message_with_code(LogCode.EXCEL_FILE_NOT_FOUND_PATH)
                     return self.create_success_result(data={'metadata': {}})
+
+                excel_metadata = metadata_strategy.extract(excel_path)
+
+            elif excel_metadata_config:
+                # Base64 encoded approach
+                excel_path, is_temp = self._resolve_excel_path_from_base64(excel_metadata_config, context)
+
+                if not excel_path or not excel_path.exists():
+                    context.run.log_message_with_code(LogCode.EXCEL_FILE_NOT_FOUND_PATH)
+                    return self.create_success_result(data={'metadata': {}})
+
+                # Track temp file for cleanup
+                if is_temp:
+                    temp_file_to_cleanup = excel_path
+
                 excel_metadata = metadata_strategy.extract(excel_path)
             else:
                 # Look for default metadata files (meta.xlsx, meta.xls)
@@ -65,9 +82,9 @@ class ProcessMetadataStep(BaseStep):
             return self.create_error_result(f'Excel security violation: {str(e)}')
 
         except ExcelParsingError as e:
-            # If excel_metadata_path was specified, this is an error
+            # If excel_metadata_path or excel_metadata was specified, this is an error
             # If we were just looking for default files, it's not an error
-            if context.get_param('excel_metadata_path'):
+            if context.get_param('excel_metadata_path') or context.get_param('excel_metadata'):
                 context.run.log_message_with_code(LogCode.EXCEL_PARSING_ERROR, str(e))
                 return self.create_error_result(f'Excel parsing error: {str(e)}')
             else:
@@ -77,6 +94,15 @@ class ProcessMetadataStep(BaseStep):
         except Exception as e:
             return self.create_error_result(f'Unexpected error processing metadata: {str(e)}')
 
+        finally:
+            # Clean up temporary file if it was created from base64
+            if temp_file_to_cleanup and temp_file_to_cleanup.exists():
+                try:
+                    temp_file_to_cleanup.unlink()
+                    context.run.log_message(f'Cleaned up temporary Excel file: {temp_file_to_cleanup}')
+                except Exception as e:
+                    context.run.log_message(f'Failed to clean up temporary file {temp_file_to_cleanup}: {str(e)}')
+
     def can_skip(self, context: UploadContext) -> bool:
         """Metadata step can be skipped if no metadata strategy is configured."""
         return 'metadata' not in context.strategies
@@ -86,6 +112,72 @@ class ProcessMetadataStep(BaseStep):
         # Clear any loaded metadata
         context.metadata.clear()
 
+    def _resolve_excel_path_from_string(self, excel_path_str: str, context: UploadContext) -> tuple[Path | None, bool]:
+        """Resolve Excel metadata path from a string path.
+
+        Note: This method supports the excel_metadata_path parameter which will be deprecated
+        in a future version. Consider using _resolve_excel_path_from_base64 instead.
+
+        Args:
+            excel_path_str: File path string to the Excel metadata file
+            context: Upload context for resolving relative paths
+
+        Returns:
+            Tuple of (resolved_path, is_temporary_file)
+            - resolved_path: Path object pointing to the Excel file, or None if resolution failed
+            - is_temporary_file: Always False for path-based approach
+
+        Examples:
+            >>> path, is_temp = self._resolve_excel_path_from_string("/data/meta.xlsx", context)
+        """
+        # TODO: Plan to deprecate this method in a few versions (backward compatibility)
+        # Try absolute path first
+        path = Path(excel_path_str)
+        if path.exists() and path.is_file():
+            return path, False
+
+        # Try relative to cwd
+        path = context.pathlib_cwd / excel_path_str
+        return (path, False) if path.exists() else (None, False)
+
+    def _resolve_excel_path_from_base64(
+        self, excel_config: dict | ExcelMetadataFile, context: UploadContext
+    ) -> tuple[Path | None, bool]:
+        """Resolve Excel metadata path from base64 encoded data.
+
+        Args:
+            excel_config: Either a dict or an ExcelMetadataFile object with base64 data
+            context: Upload context for logging
+
+        Returns:
+            Tuple of (resolved_path, is_temporary_file)
+            - resolved_path: Path object pointing to the temporary Excel file, or None if decoding failed
+            - is_temporary_file: Always True for base64 approach (requires cleanup)
+
+        Examples:
+            >>> config = ExcelMetadataFile(data="UEsDB...", filename="meta.xlsx")
+            >>> path, is_temp = self._resolve_excel_path_from_base64(config, context)
+        """
+        if isinstance(excel_config, dict):
+            excel_config = ExcelMetadataFile(**excel_config)
+
+        try:
+            # Decode base64 data
+            decoded_data = base64.b64decode(excel_config.data, validate=True)
+
+            # Create temp file
+            temp_dir = Path(tempfile.gettempdir())
+            filename = excel_config.filename
+            temp_file = temp_dir / filename
+            temp_file.write_bytes(decoded_data)
+
+            context.run.log_message(f'Decoded base64 Excel metadata to temporary file: {temp_file}')
+            return temp_file, True
+
+        except Exception as e:
+            context.run.log_message(f'Failed to decode base64 Excel metadata: {str(e)}')
+            return None, False
+
     def _find_excel_metadata_file(self, pathlib_cwd: Path) -> Path:
         """Find default Excel metadata file."""
         # Check .xlsx first as it's more common

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

@@ -24,51 +24,128 @@ class OrganizeFilesStep(BaseStep):
             return self.create_error_result('File specifications not available')
 
         try:
-            # Create type directories mapping
-            type_dirs = {}
-            for spec in context.file_specifications:
-                spec_name = spec['name']
-                spec_dir = context.pathlib_cwd / spec_name
-                if spec_dir.exists() and spec_dir.is_dir():
-                    type_dirs[spec_name] = spec_dir
-
-            if type_dirs:
-                context.run.log_message_with_code(LogCode.TYPE_DIRECTORIES_FOUND, list(type_dirs.keys()))
+            # Check which mode we're in
+            use_single_path = context.get_param('use_single_path', True)
+
+            if use_single_path:
+                # Single path mode: all assets use same base path
+                return self._execute_single_path_mode(context, file_discovery_strategy)
             else:
-                context.run.log_message_with_code(LogCode.NO_TYPE_DIRECTORIES)
-                return self.create_success_result(data={'organized_files': []})
+                # Multi-path mode: each asset has its own path
+                return self._execute_multi_path_mode(context, file_discovery_strategy)
 
-            context.run.log_message_with_code(LogCode.TYPE_STRUCTURE_DETECTED)
-            context.run.log_message_with_code(LogCode.FILE_ORGANIZATION_STARTED)
+        except Exception as e:
+            return self.create_error_result(f'File organization failed: {str(e)}')
 
-            # Discover files in type directories
-            all_files = []
-            is_recursive = context.get_param('is_recursive', True)
+    def _execute_single_path_mode(self, context: UploadContext, file_discovery_strategy) -> StepResult:
+        """Execute file organization in single path mode (traditional)."""
+        # Create type directories mapping
+        type_dirs = {}
+        for spec in context.file_specifications:
+            spec_name = spec['name']
+            spec_dir = context.pathlib_cwd / spec_name
+            if spec_dir.exists() and spec_dir.is_dir():
+                type_dirs[spec_name] = spec_dir
+
+        if type_dirs:
+            context.run.log_message_with_code(LogCode.TYPE_DIRECTORIES_FOUND, list(type_dirs.keys()))
+        else:
+            context.run.log_message_with_code(LogCode.NO_TYPE_DIRECTORIES)
+            return self.create_success_result(data={'organized_files': []})
+
+        context.run.log_message_with_code(LogCode.TYPE_STRUCTURE_DETECTED)
+        context.run.log_message_with_code(LogCode.FILE_ORGANIZATION_STARTED)
+
+        # Discover files in type directories
+        all_files = []
+        is_recursive = context.get_param('is_recursive', True)
+
+        for spec_name, dir_path in type_dirs.items():
+            files_in_dir = file_discovery_strategy.discover(dir_path, is_recursive)
+            all_files.extend(files_in_dir)
+
+        if not all_files:
+            context.run.log_message_with_code(LogCode.NO_FILES_FOUND_WARNING)
+            return self.create_success_result(data={'organized_files': []})
+
+        # Organize files using strategy
+        organized_files = file_discovery_strategy.organize(
+            all_files, context.file_specifications, context.metadata or {}, type_dirs
+        )
+
+        if organized_files:
+            context.run.log_message_with_code(LogCode.FILES_DISCOVERED, len(organized_files))
+            context.add_organized_files(organized_files)
+
+        return self.create_success_result(
+            data={'organized_files': organized_files},
+            rollback_data={'files_count': len(organized_files), 'type_dirs': list(type_dirs.keys())},
+        )
+
+    def _execute_multi_path_mode(self, context: UploadContext, file_discovery_strategy) -> StepResult:
+        """Execute file organization in multi-path mode (each asset has own path)."""
+        from synapse_sdk.utils.storage import get_pathlib
+
+        assets = context.get_param('assets', {})
+        if not assets:
+            return self.create_error_result('Multi-path mode requires assets configuration')
+
+        context.run.log_message(f'Using multi-path mode with {len(assets)} asset configurations')
+        context.run.log_message_with_code(LogCode.FILE_ORGANIZATION_STARTED)
+
+        all_organized_files = []
+        type_dirs = {}
+
+        for spec in context.file_specifications:
+            spec_name = spec['name']
+
+            # Skip if no asset configuration for this spec
+            if spec_name not in assets:
+                context.run.log_message(f'Skipping {spec_name}: no asset path configured')
+                continue
+
+            asset_config = assets[spec_name]
+
+            # Get the asset path from storage
+            try:
+                asset_path = get_pathlib(context.storage, asset_config.path)
+                type_dirs[spec_name] = asset_path
+            except Exception as e:
+                context.run.log_message(f'Error accessing path for {spec_name}: {str(e)}', 'WARNING')
+                continue
+
+            if not asset_path.exists():
+                context.run.log_message(f'Path does not exist for {spec_name}: {asset_config.path}', 'WARNING')
+                continue
+
+            # Discover files for this asset
+            is_recursive = asset_config.is_recursive
+            context.run.log_message(
+                f'Discovering files for {spec_name} at {asset_config.path} (recursive={is_recursive})'
+            )
 
-            for spec_name, dir_path in type_dirs.items():
-                files_in_dir = file_discovery_strategy.discover(dir_path, is_recursive)
-                all_files.extend(files_in_dir)
+            files = file_discovery_strategy.discover(asset_path, is_recursive)
 
-            if not all_files:
-                context.run.log_message_with_code(LogCode.NO_FILES_FOUND_WARNING)
-                return self.create_success_result(data={'organized_files': []})
+            if not files:
+                context.run.log_message(f'No files found for {spec_name}', 'WARNING')
+                continue
 
-            # Organize files using strategy
-            organized_files = file_discovery_strategy.organize(
-                all_files, context.file_specifications, context.metadata or {}, type_dirs
-            )
+            # Organize files for this specific spec
+            organized = file_discovery_strategy.organize(files, [spec], context.metadata or {}, {spec_name: asset_path})
 
-            if organized_files:
-                context.run.log_message_with_code(LogCode.FILES_DISCOVERED, len(organized_files))
-                context.add_organized_files(organized_files)
+            all_organized_files.extend(organized)
+            context.run.log_message(f'Found {len(organized)} files for {spec_name}')
 
-            return self.create_success_result(
-                data={'organized_files': organized_files},
-                rollback_data={'files_count': len(organized_files), 'type_dirs': list(type_dirs.keys())},
-            )
+        if all_organized_files:
+            context.run.log_message_with_code(LogCode.FILES_DISCOVERED, len(all_organized_files))
+            context.add_organized_files(all_organized_files)
+        else:
+            context.run.log_message_with_code(LogCode.NO_FILES_FOUND_WARNING)
 
-        except Exception as e:
-            return self.create_error_result(f'File organization failed: {str(e)}')
+        return self.create_success_result(
+            data={'organized_files': all_organized_files},
+            rollback_data={'files_count': len(all_organized_files), 'type_dirs': list(type_dirs.keys())},
+        )
 
     def can_skip(self, context: UploadContext) -> bool:
         """File organization cannot be skipped."""