synapse-sdk 2025.9.1__py3-none-any.whl → 2025.9.3__py3-none-any.whl

synapse_sdk/plugins/categories/upload/actions/upload/strategies/file_discovery/recursive.py

@@ -0,0 +1,238 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List
+
+from ..base import FileDiscoveryStrategy
+
+
+class RecursiveFileDiscoveryStrategy(FileDiscoveryStrategy):
+    """Recursive file discovery strategy."""
+
+    def discover(self, path: Path, recursive: bool) -> List[Path]:
+        """Discover files recursively in the given path."""
+        return [file_path for file_path in path.rglob('*') if file_path.is_file()]
+
+    def organize(self, files: List[Path], specs: Dict, metadata: Dict, type_dirs: Dict = None) -> List[Dict]:
+        """Organize files according to specifications with metadata."""
+        organized_files = []
+
+        # Use provided type_dirs or create fallback mapping
+        if type_dirs is None:
+            type_dirs = {}
+            for spec in specs:
+                spec_name = spec['name']
+                # Fallback: extract spec directory from file paths
+                for file_path in files:
+                    # Check if this file's path contains the spec_name as a directory
+                    path_parts = file_path.parts
+                    if spec_name in path_parts:
+                        # Find the index of spec_name and reconstruct the path up to that directory
+                        spec_index = path_parts.index(spec_name)
+                        spec_dir = Path(*path_parts[: spec_index + 1])
+                        if spec_dir.exists() and spec_dir.is_dir():
+                            type_dirs[spec_name] = spec_dir
+                            break
+
+        if not type_dirs:
+            return organized_files
+
+        # Performance optimization 1: Path caching - avoid repeated string conversions
+        path_cache = {dir_path: str(dir_path) for dir_path in type_dirs.values()}
+
+        # Performance optimization 2: Build metadata index for faster lookups
+        metadata_index = self._build_metadata_index(metadata)
+
+        # Group files by dataset
+        dataset_files = {}
+        required_specs = [spec['name'] for spec in specs if spec.get('is_required', False)]
+
+        for file_path in files:
+            # Determine which type directory this file belongs to
+            file_path_str = str(file_path)
+            for spec_name, dir_path in type_dirs.items():
+                dir_path_str = path_cache[dir_path]
+                if file_path_str.startswith(dir_path_str):
+                    file_name = file_path.stem
+
+                    if file_name not in dataset_files:
+                        dataset_files[file_name] = {}
+
+                    if spec_name not in dataset_files[file_name]:
+                        dataset_files[file_name][spec_name] = file_path
+                    else:
+                        # Keep the most recent file - only stat when needed
+                        existing_file = dataset_files[file_name][spec_name]
+                        try:
+                            if file_path.stat().st_mtime > existing_file.stat().st_mtime:
+                                dataset_files[file_name][spec_name] = file_path
+                        except (OSError, IOError):
+                            # If stat fails, keep existing file
+                            pass
+
+        # Create organized files for datasets with all required files
+        for file_name, files_dict in sorted(dataset_files.items()):
+            if all(req in files_dict for req in required_specs):
+                # Calculate most common file extension (optimized)
+                file_extensions = {}
+                for file_path in files_dict.values():
+                    ext = file_path.suffix.lower()
+                    if ext:
+                        file_extensions[ext] = file_extensions.get(ext, 0) + 1
+
+                origin_file_extension = max(file_extensions, key=file_extensions.get) if file_extensions else ''
+
+                meta_data = {
+                    'origin_file_stem': file_name,
+                    'origin_file_extension': origin_file_extension,
+                    'created_at': datetime.now().isoformat(),
+                }
+
+                # Add metadata if available - using optimized index lookup
+                if metadata_index:
+                    matched_metadata = self._find_matching_metadata_optimized(file_name, files_dict, metadata_index)
+                    if matched_metadata:
+                        meta_data.update(matched_metadata)
+
+                organized_files.append({'files': files_dict, 'meta': meta_data})
+
+        return organized_files
+
+    def _build_metadata_index(self, metadata: Dict) -> Dict:
+        """Build metadata index for faster lookups."""
+        if not metadata:
+            return {}
+
+        metadata_index = {'exact_stem': {}, 'exact_name': {}, 'stem_lookup': {}, 'partial_paths': {}, 'full_paths': {}}
+
+        for meta_key, meta_value in metadata.items():
+            meta_path = Path(meta_key)
+
+            # Index by stem
+            stem = meta_path.stem
+            if stem:
+                metadata_index['exact_stem'][stem] = meta_value
+                metadata_index['stem_lookup'][stem] = meta_value
+
+            # Index by full name
+            name = meta_path.name
+            if name:
+                metadata_index['exact_name'][name] = meta_value
+
+            # Index for partial path matching
+            metadata_index['partial_paths'][meta_key] = meta_value
+
+            # Index for full path matching
+            metadata_index['full_paths'][meta_key] = meta_value
+
+        return metadata_index
+
+    def _find_matching_metadata_optimized(self, file_name: str, files_dict: Dict, metadata_index: Dict) -> Dict:
+        """Find matching metadata using optimized index lookups."""
+        if not metadata_index:
+            return {}
+
+        # Strategy 1: Exact stem match (O(1) lookup)
+        if file_name in metadata_index['exact_stem']:
+            return metadata_index['exact_stem'][file_name]
+
+        # Strategy 2: Exact filename match with extension (O(1) lookup)
+        sample_file = list(files_dict.values())[0] if files_dict else None
+        if sample_file:
+            full_filename = f'{file_name}{sample_file.suffix}'
+            if full_filename in metadata_index['exact_name']:
+                return metadata_index['exact_name'][full_filename]
+
+            # Try sample file name
+            sample_filename = sample_file.name
+            if sample_filename in metadata_index['exact_name']:
+                return metadata_index['exact_name'][sample_filename]
+
+        # Strategy 3: Stem lookup (already optimized above)
+        # This is covered by exact_stem lookup
+
+        # Strategy 4 & 5: Partial and full path matching (fallback to original logic for complex cases)
+        if sample_file:
+            file_path_str = str(sample_file)
+            file_path_posix = sample_file.as_posix()
+
+            # Check partial paths
+            for meta_key in metadata_index['partial_paths']:
+                if (
+                    meta_key in file_path_str
+                    or meta_key in file_path_posix
+                    or file_path_str in meta_key
+                    or file_path_posix in meta_key
+                ):
+                    return metadata_index['partial_paths'][meta_key]
+
+        return {}
+
+    def _find_matching_metadata(self, file_name: str, files_dict: Dict, metadata: Dict) -> Dict:
+        """Find matching metadata using comprehensive pattern matching.
+
+        Matching priority:
+        1. Exact stem match (highest priority)
+        2. Exact filename match (with extension)
+        3. Metadata key stem matches file stem
+        4. Partial path matching
+        5. Full path matching
+        """
+        if not metadata:
+            return {}
+
+        # Get sample file for extension and path information
+        sample_file = list(files_dict.values())[0] if files_dict else None
+
+        # Strategy 1: Exact stem match (highest priority)
+        if file_name in metadata:
+            return metadata[file_name]
+
+        # Strategy 2: Exact filename match (with extension)
+        if sample_file:
+            full_filename = f'{file_name}{sample_file.suffix}'
+            if full_filename in metadata:
+                return metadata[full_filename]
+
+            # Also try with sample file name
+            sample_filename = sample_file.name
+            if sample_filename in metadata:
+                return metadata[sample_filename]
+
+        # Strategy 3: Metadata key stem matches file stem
+        for meta_key in metadata.keys():
+            meta_stem = Path(meta_key).stem
+            if meta_stem == file_name:
+                return metadata[meta_key]
+
+        # Strategy 4: Partial path matching
+        if sample_file:
+            file_path_parts = sample_file.parts
+            for meta_key in metadata.keys():
+                meta_path = Path(meta_key)
+                # Check if any part of the metadata key matches our file path parts
+                for part in file_path_parts:
+                    if part in str(meta_path) or str(meta_path) in part:
+                        # Additional validation: ensure it's a reasonable match
+                        if meta_path.stem == file_name or meta_path.name == sample_file.name or part == meta_path.stem:
+                            return metadata[meta_key]
+
+        # Strategy 5: Full path matching
+        if sample_file:
+            full_path_str = str(sample_file)
+            full_path_posix = sample_file.as_posix()
+
+            for meta_key in metadata.keys():
+                # Direct path match
+                if meta_key == full_path_str or meta_key == full_path_posix:
+                    return metadata[meta_key]
+
+                # Relative path match (check if meta_key is contained in our path)
+                if meta_key in full_path_str or meta_key in full_path_posix:
+                    return metadata[meta_key]
+
+                # Reverse match (check if our path is contained in meta_key)
+                if full_path_str in meta_key or full_path_posix in meta_key:
+                    return metadata[meta_key]
+
+        # No match found
+        return {}

synapse_sdk/plugins/categories/upload/actions/upload/strategies/metadata/__init__.py

@@ -0,0 +1 @@
+# Metadata strategy implementations

synapse_sdk/plugins/categories/upload/actions/upload/strategies/metadata/excel.py

@@ -0,0 +1,174 @@
+from io import BytesIO
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from openpyxl import load_workbook
+from openpyxl.utils.exceptions import InvalidFileException
+
+from ...exceptions import ExcelParsingError, ExcelSecurityError
+from ...utils import ExcelMetadataUtils, ExcelSecurityConfig
+from ..base import MetadataStrategy, ValidationResult
+
+
+class ExcelMetadataStrategy(MetadataStrategy):
+    """Excel metadata extraction strategy."""
+
+    def __init__(self):
+        self.excel_config = ExcelSecurityConfig()
+        self.excel_utils = ExcelMetadataUtils(self.excel_config)
+
+    def extract(self, source_path: Path) -> Dict[str, Dict[str, Any]]:
+        """Extract metadata from Excel file."""
+        try:
+            excel_stream = self._prepare_excel_file(source_path)
+            workbook = load_workbook(excel_stream, read_only=True, data_only=True)
+            try:
+                return self._process_excel_worksheet(workbook.active)
+            finally:
+                workbook.close()
+
+        except ExcelSecurityError:
+            raise
+        except ExcelParsingError:
+            raise
+        except InvalidFileException as e:
+            raise ExcelParsingError(f'Invalid Excel file format: {str(e)}')
+        except MemoryError:
+            raise ExcelSecurityError('Excel file exceeds memory limits')
+        except (OSError, IOError) as e:
+            raise ExcelParsingError(f'File access error: {str(e)}')
+        except Exception as e:
+            # Handle ZIP file errors (Excel files are ZIP archives)
+            if 'zip file' in str(e).lower():
+                raise ExcelParsingError(f'Invalid Excel file format: {str(e)}')
+            raise ExcelParsingError(f'Unexpected error: {str(e)}')
+
+    def validate(self, metadata: Dict) -> ValidationResult:
+        """Validate extracted metadata."""
+        errors = []
+
+        if not isinstance(metadata, dict):
+            errors.append('Metadata must be a dictionary')
+            return ValidationResult(valid=False, errors=errors)
+
+        # Validate each file's metadata
+        for file_name, file_metadata in metadata.items():
+            if not isinstance(file_metadata, dict):
+                errors.append(f"Metadata for file '{file_name}' must be a dictionary")
+                continue
+
+            # Check filename length
+            if not self.excel_utils.is_valid_filename_length(file_name):
+                errors.append(f"Filename '{file_name}' exceeds maximum length")
+
+        return ValidationResult(valid=len(errors) == 0, errors=errors)
+
+    def _validate_excel_security(self, excel_path: Path) -> None:
+        """Validate Excel file security constraints."""
+        file_size = excel_path.stat().st_size
+        if file_size > self.excel_config.MAX_FILE_SIZE_BYTES:
+            raise ExcelSecurityError(
+                f'Excel file too large: {file_size} bytes (max: {self.excel_config.MAX_FILE_SIZE_BYTES})'
+            )
+
+        estimated_memory = file_size * 3
+        if estimated_memory > self.excel_config.MAX_MEMORY_USAGE_BYTES:
+            raise ExcelSecurityError(
+                f'Excel file may consume too much memory: ~{estimated_memory} bytes '
+                f'(max: {self.excel_config.MAX_MEMORY_USAGE_BYTES})'
+            )
+
+    def _prepare_excel_file(self, excel_path: Path) -> BytesIO:
+        """Prepare Excel file for processing."""
+        self._validate_excel_security(excel_path)
+        excel_bytes = excel_path.read_bytes()
+        return BytesIO(excel_bytes)
+
+    def _process_excel_headers(self, headers: tuple) -> tuple:
+        """Process Excel headers."""
+        if len(headers) < 2:
+            raise ExcelParsingError('Excel file must have at least 2 columns (file name and metadata)')
+
+        # Validate first column header (filename column)
+        first_header = str(headers[0]).strip().lower() if headers[0] else ''
+        valid_filename_headers = ['filename', 'file_name']
+
+        if first_header not in valid_filename_headers:
+            raise ExcelParsingError(
+                f'First column header must be "filename" or "file_name", got: "{headers[0]}". '
+                f'Valid options: {", ".join(valid_filename_headers)}'
+            )
+
+        self._validate_excel_content(headers, 0)
+        return headers
+
+    def _process_excel_data_row(self, row: tuple, headers: tuple) -> Optional[Dict[str, Any]]:
+        """Process a single Excel data row."""
+        if not row[0] or str(row[0]).strip() == '':
+            return None
+
+        file_name = str(row[0]).strip()
+        if not self.excel_utils.is_valid_filename_length(file_name):
+            return None
+
+        file_metadata: Dict[str, Any] = {}
+        for i, value in enumerate(row[1:], start=1):
+            if i < len(headers):  # Include empty strings, exclude only None values
+                header_value = headers[i]
+                column_name = str(header_value).strip() if header_value is not None else f'column_{i}'
+
+                column_name = self.excel_utils.validate_and_truncate_string(
+                    column_name, self.excel_config.MAX_COLUMN_NAME_LENGTH
+                )
+
+                # Convert None to empty string, otherwise convert to string
+                value_str = '' if value is None else str(value)
+                str_value = self.excel_utils.validate_and_truncate_string(
+                    value_str, self.excel_config.MAX_METADATA_VALUE_LENGTH
+                )
+                file_metadata[column_name] = str_value
+
+        return {file_name: file_metadata} if file_metadata else None
+
+    def _process_excel_worksheet(self, worksheet) -> Dict[str, Dict[str, Any]]:
+        """Process Excel worksheet."""
+        if worksheet is None:
+            raise ExcelParsingError('Excel file has no active worksheet')
+
+        metadata_dict: Dict[str, Dict[str, Any]] = {}
+        headers: Optional[tuple] = None
+        data_row_count = 0
+        validation_interval = getattr(self.excel_config, 'VALIDATION_CHECK_INTERVAL', 1000)
+
+        for row_idx, row in enumerate(worksheet.iter_rows(values_only=True)):
+            # Quick check: if row is empty or first cell is empty, skip
+            if not row or not row[0] or str(row[0]).strip() == '':
+                continue
+
+            if row_idx == 0:
+                headers = self._process_excel_headers(row)
+                continue
+
+            if headers is None:
+                raise ExcelParsingError('Excel file missing header row')
+
+            data_row_count += 1
+
+            if data_row_count % validation_interval == 0:
+                self._validate_excel_content(headers, data_row_count)
+
+            row_result = self._process_excel_data_row(row, headers)
+            if row_result:
+                metadata_dict.update(row_result)
+
+        self._validate_excel_content(headers or (), data_row_count)
+
+        return metadata_dict
+
+    def _validate_excel_content(self, headers: tuple, row_count: int) -> None:
+        """Validate Excel content constraints."""
+        if len(headers) > self.excel_config.MAX_COLUMNS:
+            raise ExcelParsingError(f'Too many columns: {len(headers)} (max: {self.excel_config.MAX_COLUMNS})')
+
+        if row_count > self.excel_config.MAX_ROWS:
+            raise ExcelParsingError(f'Too many rows: {row_count} (max: {self.excel_config.MAX_ROWS})')

synapse_sdk/plugins/categories/upload/actions/upload/strategies/metadata/none.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from typing import Any, Dict
+
+from ..base import MetadataStrategy, ValidationResult
+
+
+class NoneMetadataStrategy(MetadataStrategy):
+    """Metadata strategy that returns no metadata."""
+
+    def extract(self, source_path: Path) -> Dict[str, Dict[str, Any]]:
+        """Return empty metadata."""
+        return {}
+
+    def validate(self, metadata: Dict) -> ValidationResult:
+        """Always validates successfully for empty metadata."""
+        return ValidationResult(valid=True)

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

@@ -0,0 +1 @@
+# Upload strategy implementations

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

@@ -0,0 +1,109 @@
+import asyncio
+from pathlib import Path
+from typing import Any, Dict, List
+
+from synapse_sdk.clients.exceptions import ClientError
+
+from ...enums import LogCode, UploadStatus
+from ..base import UploadConfig, UploadStrategy
+
+
+class AsyncUploadStrategy(UploadStrategy):
+    """Asynchronous upload strategy."""
+
+    def __init__(self, context):
+        self.context = context
+
+    def upload(self, files: List[Dict], config: UploadConfig) -> List[Dict]:
+        """Upload files asynchronously."""
+        # Use the run_async helper from the action
+        return self._run_async_upload(files, config)
+
+    def _run_async_upload(self, files: List[Dict], config: UploadConfig) -> List[Dict]:
+        """Run async upload using asyncio."""
+        import concurrent.futures
+
+        def _run_in_thread():
+            return asyncio.run(self._upload_files_async(files, config))
+
+        try:
+            # Check if we're already in an event loop
+            asyncio.get_running_loop()
+            # If we are, run in a separate thread
+            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 run directly
+            return asyncio.run(self._upload_files_async(files, config))
+
+    async def _upload_files_async(self, organized_files: List[Dict], config: UploadConfig) -> List[Dict]:
+        """Upload files asynchronously with concurrency control."""
+        client = self.context.client
+        collection_id = self.context.get_param('data_collection')
+        upload_result = []
+
+        semaphore = asyncio.Semaphore(config.max_concurrent)
+
+        async def upload_single_file(organized_file):
+            async with semaphore:
+                loop = asyncio.get_event_loop()
+                try:
+                    use_chunked_upload = self._requires_chunked_upload(organized_file, config)
+                    uploaded_data_file = await loop.run_in_executor(
+                        None, lambda: client.upload_data_file(organized_file, collection_id, use_chunked_upload)
+                    )
+                    self.context.run.log_data_file(organized_file, UploadStatus.SUCCESS)
+                    return {'status': 'success', 'result': uploaded_data_file}
+                except ClientError as e:
+                    self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.context.run.log_message_with_code(LogCode.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:
+                    self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.context.run.log_message_with_code(LogCode.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:
+                    self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.context.run.log_message_with_code(
+                        LogCode.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:
+                    self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.context.run.log_message_with_code(LogCode.FILE_UPLOAD_FAILED, f'Upload timeout: {str(e)}')
+                    return {'status': 'failed', 'error': str(e), 'error_type': 'timeout_error', 'retryable': True}
+                except ValueError as e:
+                    self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.context.run.log_message_with_code(
+                        LogCode.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:
+                    self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                    self.context.run.log_message_with_code(LogCode.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 completed tasks
+        for completed_task in asyncio.as_completed(tasks):
+            result = await completed_task
+            if result['status'] == 'success':
+                upload_result.append(result['result'])
+            # Failed uploads are logged but don't stop the process
+
+        return upload_result
+
+    def _requires_chunked_upload(self, organized_file: Dict[str, Any], config: UploadConfig) -> bool:
+        """Determine if chunked upload is required based on file sizes."""
+        max_file_size_mb = config.chunked_threshold_mb
+        for file_path in organized_file.get('files', {}).values():
+            if isinstance(file_path, Path) and self._get_file_size_mb(file_path) > max_file_size_mb:
+                return True
+        return False
+
+    def _get_file_size_mb(self, file_path: Path) -> float:
+        """Get file size in megabytes."""
+        return file_path.stat().st_size / (1024 * 1024)

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

@@ -0,0 +1,43 @@
+from pathlib import Path
+from typing import Any, Dict, List
+
+from ...enums import LogCode, UploadStatus
+from ..base import UploadConfig, UploadStrategy
+
+
+class SyncUploadStrategy(UploadStrategy):
+    """Synchronous upload strategy."""
+
+    def __init__(self, context):
+        self.context = context
+
+    def upload(self, files: List[Dict], config: UploadConfig) -> List[Dict]:
+        """Upload files synchronously."""
+        uploaded_files = []
+        client = self.context.client
+        collection_id = self.context.get_param('data_collection')
+
+        for organized_file in files:
+            try:
+                use_chunked_upload = self._requires_chunked_upload(organized_file, config)
+                uploaded_data_file = client.upload_data_file(organized_file, collection_id, use_chunked_upload)
+                self.context.run.log_data_file(organized_file, UploadStatus.SUCCESS)
+                uploaded_files.append(uploaded_data_file)
+            except Exception as e:
+                self.context.run.log_data_file(organized_file, UploadStatus.FAILED)
+                self.context.run.log_message_with_code(LogCode.FILE_UPLOAD_FAILED, str(e))
+                # Continue with other files instead of failing completely
+
+        return uploaded_files
+
+    def _requires_chunked_upload(self, organized_file: Dict[str, Any], config: UploadConfig) -> bool:
+        """Determine if chunked upload is required based on file sizes."""
+        max_file_size_mb = config.chunked_threshold_mb
+        for file_path in organized_file.get('files', {}).values():
+            if isinstance(file_path, Path) and self._get_file_size_mb(file_path) > max_file_size_mb:
+                return True
+        return False
+
+    def _get_file_size_mb(self, file_path: Path) -> float:
+        """Get file size in megabytes."""
+        return file_path.stat().st_size / (1024 * 1024)

synapse_sdk/plugins/categories/upload/actions/upload/strategies/validation/__init__.py

@@ -0,0 +1 @@
+# Validation strategy implementations

synapse_sdk/plugins/categories/upload/actions/upload/strategies/validation/default.py

@@ -0,0 +1,45 @@
+from typing import Dict, List
+
+from synapse_sdk.clients.validators.collections import FileSpecificationValidator
+
+from ..base import ValidationResult, ValidationStrategy
+
+
+class DefaultValidationStrategy(ValidationStrategy):
+    """Default validation strategy for upload operations."""
+
+    def validate_params(self, params: Dict) -> ValidationResult:
+        """Validate action parameters."""
+        errors = []
+
+        # Check required parameters
+        required_params = ['storage', 'data_collection', 'path', 'name']
+        for param in required_params:
+            if param not in params:
+                errors.append(f'Missing required parameter: {param}')
+
+        # Check parameter types
+        if 'storage' in params and not isinstance(params['storage'], int):
+            errors.append("Parameter 'storage' must be an integer")
+
+        if 'data_collection' in params and not isinstance(params['data_collection'], int):
+            errors.append("Parameter 'data_collection' must be an integer")
+
+        if 'is_recursive' in params and not isinstance(params['is_recursive'], bool):
+            errors.append("Parameter 'is_recursive' must be a boolean")
+
+        return ValidationResult(valid=len(errors) == 0, errors=errors)
+
+    def validate_files(self, files: List[Dict], specs: Dict) -> ValidationResult:
+        """Validate organized files against specifications."""
+        try:
+            validator = FileSpecificationValidator(specs, files)
+            is_valid = validator.validate()
+
+            if is_valid:
+                return ValidationResult(valid=True)
+            else:
+                return ValidationResult(valid=False, errors=['File specification validation failed'])
+
+        except Exception as e:
+            return ValidationResult(valid=False, errors=[f'Validation error: {str(e)}'])