synapse-sdk 1.0.0b8__py3-none-any.whl → 1.0.0b10__py3-none-any.whl

synapse_sdk/clients/agent/ray.py

@@ -1,10 +1,87 @@
-import requests
+import weakref
+from concurrent.futures import ThreadPoolExecutor
 
 from synapse_sdk.clients.base import BaseClient
 from synapse_sdk.clients.exceptions import ClientError
+from synapse_sdk.utils.network import (
+    HTTPStreamManager,
+    StreamLimits,
+    WebSocketStreamManager,
+    http_to_websocket_url,
+    sanitize_error_message,
+    validate_resource_id,
+    validate_timeout,
+)
 
 
 class RayClientMixin(BaseClient):
+    """
+    Mixin class providing Ray cluster management and monitoring functionality.
+
+    This mixin extends BaseClient with Ray-specific operations for interacting with
+    Apache Ray distributed computing clusters. It provides comprehensive job management,
+    node monitoring, task tracking, and Ray Serve application control capabilities.
+
+    Key Features:
+        - Job lifecycle management (list, get, monitor)
+        - Real-time log streaming via WebSocket and HTTP protocols
+        - Node and task monitoring
+        - Ray Serve application deployment and management
+        - Robust error handling with input validation
+        - Resource management with automatic cleanup
+
+    Streaming Capabilities:
+        - WebSocket streaming for real-time log tailing
+        - HTTP streaming as fallback protocol
+        - Configurable timeouts and stream limits
+        - Automatic protocol validation and error recovery
+
+    Resource Management:
+        - Thread pool for concurrent operations (5 workers)
+        - WeakSet for tracking active connections
+        - Automatic cleanup on object destruction
+        - Stream limits to prevent resource exhaustion
+
+    Usage Examples:
+        Basic job operations:
+            >>> client = RayClient(base_url="http://ray-head:8265")
+            >>> jobs = client.list_jobs()
+            >>> job = client.get_job('job-12345')
+
+        Real-time log streaming:
+            >>> # WebSocket streaming (preferred)
+            >>> for log_line in client.tail_job_logs('job-12345', protocol='websocket'):
+            ...     print(log_line)
+
+            >>> # HTTP streaming (fallback)
+            >>> for log_line in client.tail_job_logs('job-12345', protocol='stream'):
+            ...     print(log_line)
+
+        Node and task monitoring:
+            >>> nodes = client.list_nodes()
+            >>> tasks = client.list_tasks()
+            >>> node_details = client.get_node('node-id')
+
+        Ray Serve management:
+            >>> apps = client.list_serve_applications()
+            >>> client.delete_serve_application('app-id')
+
+    Note:
+        This class is designed as a mixin and should be combined with other
+        client classes that provide authentication and base functionality.
+        It requires the BaseClient foundation for HTTP operations.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._thread_pool = ThreadPoolExecutor(max_workers=5, thread_name_prefix='ray_client_')
+        self._active_connections = weakref.WeakSet()
+
+        # Initialize stream managers
+        stream_limits = StreamLimits()
+        self._websocket_manager = WebSocketStreamManager(self._thread_pool, stream_limits)
+        self._http_manager = HTTPStreamManager(self.requests_session, stream_limits)
+
     def get_job(self, pk):
         path = f'jobs/{pk}/'
         return self._get(path)
@@ -17,48 +94,181 @@ class RayClientMixin(BaseClient):
         path = f'jobs/{pk}/logs/'
         return self._get(path)
 
-    def tail_job_logs(self, pk, stream_timeout=10):
-        if self.long_poll_handler:
-            raise ClientError(400, '"tail_job_logs" does not support long polling')
+    def websocket_tail_job_logs(self, pk, stream_timeout=10):
+        """
+        Stream job logs in real-time using WebSocket protocol.
+
+        Establishes a WebSocket connection to stream job logs as they are generated.
+        This method provides the lowest latency for real-time log monitoring and is
+        the preferred protocol when available.
+
+        Args:
+            pk (str): Job primary key or identifier. Must be alphanumeric with
+                     optional hyphens/underscores, max 100 characters.
+            stream_timeout (float, optional): Maximum time in seconds to wait for
+                                            log data. Defaults to 10. Must be positive
+                                            and cannot exceed 300 seconds.
+
+        Returns:
+            Generator[str, None, None]: A generator yielding log lines as strings.
+                                      Each line includes a newline character.
+
+        Raises:
+            ClientError:
+                - 400: If long polling is enabled (incompatible)
+                - 400: If pk is empty, contains invalid characters, or too long
+                - 400: If stream_timeout is not positive or exceeds maximum
+                - 500: If WebSocket library is unavailable
+                - 503: If connection to Ray cluster fails
+                - 408: If connection timeout occurs
+                - 429: If stream limits are exceeded (lines, size, messages)
+
+        Usage:
+            >>> # Basic log streaming
+            >>> for log_line in client.websocket_tail_job_logs('job-12345'):
+            ...     print(log_line.strip())
+
+            >>> # With custom timeout
+            >>> for log_line in client.websocket_tail_job_logs('job-12345', stream_timeout=30):
+            ...     if 'ERROR' in log_line:
+            ...         break
+
+        Technical Notes:
+            - Uses WebSocketStreamManager for connection management
+            - Automatic input validation and sanitization
+            - Resource cleanup handled by WeakSet tracking
+            - Stream limits prevent memory exhaustion
+            - Thread pool manages WebSocket operations
+
+        See Also:
+            stream_tail_job_logs: HTTP-based alternative
+            tail_job_logs: Protocol-agnostic wrapper method
+        """
+        if hasattr(self, 'long_poll_handler') and self.long_poll_handler:
+            raise ClientError(400, '"websocket_tail_job_logs" does not support long polling')
+
+        # Validate inputs using network utilities
+        validated_pk = validate_resource_id(pk, 'job')
+        validated_timeout = validate_timeout(stream_timeout)
 
-        path = f'jobs/{pk}/tail_logs/'
+        # Build WebSocket URL
+        path = f'ray/jobs/{validated_pk}/logs/ws/'
         url = self._get_url(path)
+        ws_url = http_to_websocket_url(url)
+
+        # Get headers and use WebSocket manager
         headers = self._get_headers()
+        context = f'job {validated_pk}'
+
+        return self._websocket_manager.stream_logs(ws_url, headers, validated_timeout, context)
+
+    def stream_tail_job_logs(self, pk, stream_timeout=10):
+        """
+        Stream job logs in real-time using HTTP chunked transfer encoding.
+
+        Establishes an HTTP connection with chunked transfer encoding to stream
+        job logs as they are generated. This method serves as a reliable fallback
+        when WebSocket connections are not available or suitable.
+
+        Args:
+            pk (str): Job primary key or identifier. Must be alphanumeric with
+                     optional hyphens/underscores, max 100 characters.
+            stream_timeout (float, optional): Maximum time in seconds to wait for
+                                            log data. Defaults to 10. Must be positive
+                                            and cannot exceed 300 seconds.
+
+        Returns:
+            Generator[str, None, None]: A generator yielding log lines as strings.
+                                      Each line includes a newline character.
+
+        Raises:
+            ClientError:
+                - 400: If long polling is enabled (incompatible)
+                - 400: If pk is empty, contains invalid characters, or too long
+                - 400: If stream_timeout is not positive or exceeds maximum
+                - 503: If connection to Ray cluster fails
+                - 408: If connection or read timeout occurs
+                - 404: If job is not found
+                - 429: If stream limits are exceeded (lines, size, messages)
+                - 500: If unexpected streaming error occurs
+
+        Usage:
+            >>> # Basic HTTP log streaming
+            >>> for log_line in client.stream_tail_job_logs('job-12345'):
+            ...     print(log_line.strip())
+
+            >>> # With error handling and custom timeout
+            >>> try:
+            ...     for log_line in client.stream_tail_job_logs('job-12345', stream_timeout=60):
+            ...         if 'COMPLETED' in log_line:
+            ...             break
+            ... except ClientError as e:
+            ...     print(f"Streaming failed: {e}")
+
+        Technical Notes:
+            - Uses HTTPStreamManager for connection management
+            - Automatic input validation and sanitization
+            - Proper HTTP response cleanup on completion/error
+            - Stream limits prevent memory exhaustion
+            - Filters out oversized lines (>10KB) automatically
+            - Connection reuse through requests session
+
+        See Also:
+            websocket_tail_job_logs: WebSocket-based alternative (preferred)
+            tail_job_logs: Protocol-agnostic wrapper method
+        """
+        if hasattr(self, 'long_poll_handler') and self.long_poll_handler:
+            raise ClientError(400, '"stream_tail_job_logs" does not support long polling')
+
+        # Validate inputs using network utilities
+        validated_pk = validate_resource_id(pk, 'job')
+        validated_timeout = validate_timeout(stream_timeout)
+
+        # Build HTTP URL and prepare request
+        path = f'ray/jobs/{validated_pk}/logs/stream'
+        url = self._get_url(path)
+        headers = self._get_headers()
+        timeout = (self.timeout['connect'], validated_timeout)
+        context = f'job {validated_pk}'
+
+        return self._http_manager.stream_logs(url, headers, timeout, context)
+
+    def tail_job_logs(self, pk, stream_timeout=10, protocol='stream'):
+        """
+        Tail job logs using either WebSocket or HTTP streaming.
+
+        Args:
+            pk: Job primary key
+            stream_timeout: Timeout for streaming operations
+            protocol: 'websocket' or 'stream' (default: 'stream')
+        """
+        # Validate protocol first
+        if protocol not in ('websocket', 'stream'):
+            raise ClientError(400, f'Unsupported protocol: {protocol}. Use "websocket" or "stream"')
+
+        # Pre-validate common inputs using network utilities
+        validate_resource_id(pk, 'job')
+        validate_timeout(stream_timeout)
 
         try:
-            # Use shorter timeout for streaming to prevent hanging
-            response = self.requests_session.get(
-                url, headers=headers, stream=True, timeout=(self.timeout['connect'], stream_timeout)
-            )
-            response.raise_for_status()
-
-            # Set up streaming with timeout handling
-            try:
-                for line in response.iter_lines(decode_unicode=True, chunk_size=1024):
-                    if line:
-                        yield f'{line}\n'
-            except requests.exceptions.ChunkedEncodingError:
-                # Connection was interrupted during streaming
-                raise ClientError(503, f'Log stream for job {pk} was interrupted')
-            except requests.exceptions.ReadTimeout:
-                # Read timeout during streaming
-                raise ClientError(408, f'Log stream for job {pk} timed out after {stream_timeout}s')
-
-        except requests.exceptions.ConnectTimeout:
-            raise ClientError(
-                408, f'Failed to connect to log stream for job {pk} (timeout: {self.timeout["connect"]}s)'
-            )
-        except requests.exceptions.ReadTimeout:
-            raise ClientError(408, f'Log stream for job {pk} read timeout ({stream_timeout}s)')
-        except requests.exceptions.ConnectionError as e:
-            if 'Connection refused' in str(e):
-                raise ClientError(503, f'Agent connection refused for job {pk}')
-            else:
-                raise ClientError(503, f'Agent connection error for job {pk}: {str(e)[:100]}')
-        except requests.exceptions.HTTPError as e:
-            raise ClientError(e.response.status_code, f'HTTP error streaming logs for job {pk}: {e}')
+            if protocol == 'websocket':
+                return self.websocket_tail_job_logs(pk, stream_timeout)
+            else:  # protocol == 'stream'
+                return self.stream_tail_job_logs(pk, stream_timeout)
+        except ClientError:
+            raise
         except Exception as e:
-            raise ClientError(500, f'Unexpected error streaming logs for job {pk}: {str(e)[:100]}')
+            # Fallback error handling using network utility
+            sanitized_error = sanitize_error_message(str(e), f'job {pk}')
+            raise ClientError(500, f'Protocol {protocol} failed: {sanitized_error}')
+
+    def __del__(self):
+        """Cleanup resources when object is destroyed."""
+        try:
+            if hasattr(self, '_thread_pool'):
+                self._thread_pool.shutdown(wait=False)
+        except Exception:
+            pass  # Ignore cleanup errors during destruction
 
     def get_node(self, pk):
         path = f'nodes/{pk}/'

synapse_sdk/devtools/docs/sidebars.ts

@@ -31,7 +31,26 @@ const sidebars: SidebarsConfig = {
       label: 'API Reference',
       items: [
         'api/index',
-        'api/clients/backend',
+        {
+          type: 'category',
+          label: 'Clients',
+          items: [
+            'api/clients/backend',
+            'api/clients/agent',
+            'api/clients/ray',
+            'api/clients/base',
+          ],
+        },
+        {
+          type: 'category',
+          label: 'Utilities',
+          items: [
+            'api/utils/file',
+            'api/utils/network',
+            'api/utils/storage',
+            'api/utils/types',
+          ],
+        },
       ],
     },
     'configuration',

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

@@ -862,6 +862,9 @@ class ToTaskAction(Action):
             }
 
             inference_data = client.run_plugin(pre_processor_code, inference_payload)
+            # Every inference api should return None if failed to inference.
+            if inference_data is None:
+                return {'success': False, 'error': 'Inference data is None'}
             return {'success': True, 'data': inference_data}
         except Exception as e:
             return {'success': False, 'error': f'Failed to run inference: {str(e)}'}

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

@@ -1,5 +1,6 @@
 import json
 import os
+import shutil
 from datetime import datetime
 from enum import Enum
 from io import BytesIO
@@ -45,6 +46,13 @@ class UploadStatus(str, Enum):
 
 
 class UploadRun(Run):
+    class UploadEventLog(BaseModel):
+        """Upload event log model."""
+
+        info: Optional[str] = None
+        status: Context
+        created: str
+
     class DataFileLog(BaseModel):
         """Data file log model."""
 
@@ -74,6 +82,192 @@ class UploadRun(Run):
         failed: int
         success: int
 
+    LOG_MESSAGES = {
+        # Validation errors - show in both log_message and EventLog
+        'STORAGE_VALIDATION_FAILED': {
+            'message': 'Storage validation failed.',
+            'level': Context.DANGER,
+        },
+        'COLLECTION_VALIDATION_FAILED': {
+            'message': 'Collection validation failed.',
+            'level': Context.DANGER,
+        },
+        'PROJECT_VALIDATION_FAILED': {
+            'message': 'Project validation failed.',
+            'level': Context.DANGER,
+        },
+        'VALIDATION_FAILED': {
+            'message': 'Validation failed.',
+            'level': Context.DANGER,
+        },
+        'NO_FILES_FOUND': {
+            'message': 'Files not found on the path.',
+            'level': Context.WARNING,
+        },
+        'NO_FILES_UPLOADED': {
+            'message': 'No files were uploaded.',
+            'level': Context.WARNING,
+        },
+        'NO_DATA_UNITS_GENERATED': {
+            'message': 'No data units were generated.',
+            'level': Context.WARNING,
+        },
+        'NO_TYPE_DIRECTORIES': {
+            'message': 'No type-based directory structure found.',
+            'level': Context.INFO,
+        },
+        'EXCEL_SECURITY_VIOLATION': {
+            'message': 'Excel security validation failed: {}',
+            'level': Context.DANGER,
+        },
+        'EXCEL_PARSING_ERROR': {
+            'message': 'Excel parsing failed: {}',
+            'level': Context.DANGER,
+        },
+        'EXCEL_METADATA_LOADED': {
+            'message': 'Excel metadata loaded for {} files',
+            'level': None,
+        },
+        'UPLOADING_DATA_FILES': {
+            'message': 'Uploading data files...',
+            'level': None,
+        },
+        'GENERATING_DATA_UNITS': {
+            'message': 'Generating data units...',
+            'level': None,
+        },
+        'IMPORT_COMPLETED': {
+            'message': 'Import completed.',
+            'level': None,
+        },
+        'TYPE_DIRECTORIES_FOUND': {
+            'message': 'Found type directories: {}',
+            'level': None,
+        },
+        'TYPE_STRUCTURE_DETECTED': {
+            'message': 'Detected type-based directory structure',
+            'level': None,
+        },
+        'FILES_DISCOVERED': {
+            'message': 'Discovered {} files',
+            'level': None,
+        },
+        'NO_FILES_FOUND_WARNING': {
+            'message': 'No files found.',
+            'level': Context.WARNING,
+        },
+        'FILE_UPLOAD_FAILED': {
+            'message': 'Failed to upload file: {}',
+            'level': Context.DANGER,
+        },
+        'DATA_UNIT_BATCH_FAILED': {
+            'message': 'Failed to create data units batch: {}',
+            'level': Context.DANGER,
+        },
+        'FILENAME_TOO_LONG': {
+            'message': 'Skipping file with overly long name: {}...',
+            'level': Context.WARNING,
+        },
+        'MISSING_REQUIRED_FILES': {
+            'message': '{} missing required files: {}',
+            'level': Context.WARNING,
+        },
+        'EXCEL_FILE_NOT_FOUND': {
+            'message': 'Excel metadata file not found: {}',
+            'level': Context.WARNING,
+        },
+        # Debug information - only for EventLog
+        'EXCEL_FILE_VALIDATION_STARTED': {
+            'message': 'Excel file validation started: {}',
+            'level': Context.INFO,
+        },
+        'EXCEL_WORKBOOK_LOADED': {
+            'message': 'Excel workbook loaded successfully',
+            'level': Context.INFO,
+        },
+        'FILE_ORGANIZATION_STARTED': {
+            'message': 'File organization started for directory: {}',
+            'level': Context.INFO,
+        },
+        'BATCH_PROCESSING_STARTED': {
+            'message': 'Batch processing started: {} batches of {} items each',
+            'level': Context.INFO,
+        },
+        'EXCEL_SECURITY_VALIDATION_STARTED': {
+            'message': 'Excel security validation started for file size: {} bytes',
+            'level': Context.INFO,
+        },
+        'EXCEL_MEMORY_ESTIMATION': {
+            'message': 'Excel memory estimation: {} bytes (file) * 3 = {} bytes (estimated)',
+            'level': Context.INFO,
+        },
+        'EXCEL_FILE_NOT_FOUND_PATH': {
+            'message': 'Excel metadata file not found: {}',
+            'level': Context.WARNING,
+        },
+        'EXCEL_SECURITY_VALIDATION_FAILED': {
+            'message': 'Excel security validation failed: {}',
+            'level': Context.DANGER,
+        },
+        'EXCEL_PARSING_FAILED': {
+            'message': 'Excel parsing failed: {}',
+            'level': Context.DANGER,
+        },
+        'EXCEL_INVALID_FILE_FORMAT': {
+            'message': 'Invalid Excel file format: {}',
+            'level': Context.DANGER,
+        },
+        'EXCEL_FILE_TOO_LARGE': {
+            'message': 'Excel file too large to process (memory limit exceeded)',
+            'level': Context.DANGER,
+        },
+        'EXCEL_FILE_ACCESS_ERROR': {
+            'message': 'File access error reading excel metadata: {}',
+            'level': Context.DANGER,
+        },
+        'EXCEL_UNEXPECTED_ERROR': {
+            'message': 'Unexpected error reading excel metadata: {}',
+            'level': Context.DANGER,
+        },
+    }
+
+    def log_message_with_code(self, code: str, *args, level: Optional[Context] = None):
+        """Unified logging method that handles both log_message and EventLog based on configuration."""
+        if code not in self.LOG_MESSAGES:
+            self.log_message(f'Unknown log code: {code}')
+            self.log_upload_event('UNKNOWN_LOG_CODE', code)
+            return
+
+        log_config = self.LOG_MESSAGES[code]
+        message = log_config['message'].format(*args) if args else log_config['message']
+        log_level = level or log_config['level'] or Context.INFO
+
+        # Log to message if configured
+        if log_level == Context.INFO.value:
+            self.log_message(message, context=log_level.value)
+        else:
+            self.log_upload_event(code, *args, level)
+
+    def log_upload_event(self, code: str, *args, level: Optional[Context] = None):
+        """Log upload event using predefined code."""
+        if code not in self.LOG_MESSAGES:
+            now = datetime.now().isoformat()
+            self.log(
+                'upload_event',
+                self.UploadEventLog(info=f'Unknown log code: {code}', status=Context.DANGER, created=now).model_dump(),
+            )
+            return
+
+        log_config = self.LOG_MESSAGES[code]
+        message = log_config['message'].format(*args) if args else log_config['message']
+        log_level = level or log_config['level'] or Context.INFO
+
+        now = datetime.now().isoformat()
+        self.log(
+            'upload_event',
+            self.UploadEventLog(info=message, status=log_level, created=now).model_dump(),
+        )
+
     def log_data_file(self, data_file_info: dict, status: UploadStatus):
         """Upload data_file log.
 
@@ -465,9 +659,7 @@ class UploadAction(Action):
 
         file_name = str(row[0]).strip()
         if not self.excel_utils.is_valid_filename_length(file_name):
-            self.run.log_message(
-                f'Skipping file with overly long name: {file_name[:50]}...', context=Context.WARNING.value
-            )
+            self.run.log_message_with_code('FILENAME_TOO_LONG', file_name[:50])
             return None
 
         # Create metadata dictionary from remaining columns
@@ -596,7 +788,7 @@ class UploadAction(Action):
         if self.params.get('excel_metadata_path'):
             excel_path = pathlib_cwd / self.params['excel_metadata_path']
             if not excel_path.exists():
-                self.run.log_message(f'Excel metadata file not found: {excel_path}', context=Context.WARNING.value)
+                self.run.log_message_with_code('EXCEL_FILE_NOT_FOUND_PATH', str(excel_path))
                 return {}
         else:
             # Look for default meta.xlsx or meta.xls
@@ -606,33 +798,36 @@ class UploadAction(Action):
                 return {}
 
         try:
+            self.run.log_message_with_code('EXCEL_FILE_VALIDATION_STARTED', str(excel_path))
+
             # Prepare Excel file with security validation
             excel_stream = self._prepare_excel_file(excel_path)
 
             # Load and process workbook
             workbook = load_workbook(excel_stream, read_only=True, data_only=True)
             try:
+                self.run.log_message_with_code('EXCEL_WORKBOOK_LOADED')
                 return self._process_excel_worksheet(workbook.active)
             finally:
                 workbook.close()
 
         except ExcelSecurityError as e:
-            self.run.log_message(f'Excel security validation failed: {str(e)}', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_SECURITY_VALIDATION_FAILED', str(e))
             raise
         except ExcelParsingError as e:
-            self.run.log_message(f'Excel parsing failed: {str(e)}', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_PARSING_FAILED', str(e))
             raise
         except InvalidFileException as e:
-            self.run.log_message(f'Invalid Excel file format: {str(e)}', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_INVALID_FILE_FORMAT', str(e))
             raise ExcelParsingError(f'Invalid Excel file format: {str(e)}')
         except MemoryError:
-            self.run.log_message('Excel file too large to process (memory limit exceeded)', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_FILE_TOO_LARGE')
             raise ExcelSecurityError('Excel file exceeds memory limits')
         except (OSError, IOError) as e:
-            self.run.log_message(f'File access error reading excel metadata: {str(e)}', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_FILE_ACCESS_ERROR', str(e))
             raise ExcelParsingError(f'File access error: {str(e)}')
         except Exception as e:
-            self.run.log_message(f'Unexpected error reading excel metadata: {str(e)}', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_UNEXPECTED_ERROR', str(e))
             raise ExcelParsingError(f'Unexpected error: {str(e)}')
 
     def start(self) -> Dict[str, Any]:
@@ -653,22 +848,20 @@ class UploadAction(Action):
         try:
             excel_metadata = self._read_excel_metadata(pathlib_cwd)
             if excel_metadata:
-                self.run.log_message(f'Excel metadata loaded for {len(excel_metadata)} files')
+                self.run.log_message_with_code('EXCEL_METADATA_LOADED', len(excel_metadata))
         except ExcelSecurityError as e:
             # Security violations should stop the process entirely
-            self.run.log_message(f'Excel security validation failed: {str(e)}', context=Context.ERROR.value)
-            self.run.log_message('Upload aborted due to Excel security concerns.', context=Context.ERROR.value)
+            self.run.log_message_with_code('EXCEL_SECURITY_VIOLATION', str(e))
             return result
         except ExcelParsingError as e:
             # Parsing errors can be non-critical if user didn't explicitly provide Excel file
             if self.params.get('excel_metadata_path'):
                 # User explicitly provided Excel file, treat as error
-                self.run.log_message(f'Excel parsing failed: {str(e)}', context=Context.ERROR.value)
-                self.run.log_message('Upload aborted due to Excel parsing failure.', context=Context.ERROR.value)
+                self.run.log_message_with_code('EXCEL_PARSING_ERROR', str(e))
                 return result
             else:
                 # Default Excel file found but failed to parse, treat as warning and continue
-                self.run.log_message(f'Excel parsing failed (continuing): {str(e)}', context=Context.WARNING.value)
+                self.run.log_message_with_code('EXCEL_PARSING_ERROR', str(e))
                 excel_metadata = {}
 
         # Analyze Collection file specifications to determine the data structure for upload.
@@ -684,29 +877,32 @@ class UploadAction(Action):
 
         # Validate the organized files
         if not self._validate_organized_files(organized_files, file_specification_template):
-            self.run.log_message('Validation failed.', context=Context.ERROR.value)
+            self.run.log_message_with_code('VALIDATION_FAILED')
             raise ActionError('Upload is aborted due to validation errors.')
 
         # Upload files to synapse-backend.
         if not organized_files:
-            self.run.log_message('Files not found on the path.', context=Context.WARNING.value)
+            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)
         result['uploaded_files_count'] = len(uploaded_files)
 
         # Generate data units for the uploaded data.
         if not uploaded_files:
-            self.run.log_message('No files were uploaded.', context=Context.WARNING.value)
+            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)
         result['generated_data_units_count'] = len(generated_data_units)
 
         # Setup task with uploaded synapse-backend data units.
         if not generated_data_units:
-            self.run.log_message('No data units were generated.', context=Context.WARNING.value)
+            self.run.log_message_with_code('NO_DATA_UNITS_GENERATED')
             raise ActionError('Upload is aborted due to no generated data units.')
 
-        self.run.log_message('Import completed.')
+        # Clean up if temp dir exists
+        self._cleanup_temp_directory()
+
+        self.run.log_message_with_code('IMPORT_COMPLETED')
         return result
 
     def _analyze_collection(self) -> Dict[str, Any]:
@@ -736,7 +932,7 @@ class UploadAction(Action):
         # Initialize progress
         organized_files_count = len(organized_files)
         self.run.set_progress(0, organized_files_count, category='upload_data_files')
-        self.run.log_message('Uploading data files...')
+        self.run.log_message_with_code('UPLOADING_DATA_FILES')
 
         client = self.run.client
         collection_id = self.params['data_collection']
@@ -756,7 +952,7 @@ class UploadAction(Action):
                 upload_result.append(uploaded_data_file)
             except Exception as e:
                 self.run.log_data_file(organized_file, UploadStatus.FAILED)
-                self.run.log_message(f'Failed to upload file: {str(e)}')
+                self.run.log_message_with_code('FILE_UPLOAD_FAILED', str(e))
                 failed_count += 1
 
             current_progress += 1
@@ -779,7 +975,7 @@ class UploadAction(Action):
         # Initialize progress
         upload_result_count = len(uploaded_files)
         self.run.set_progress(0, upload_result_count, category='generate_data_units')
-        self.run.log_message('Generating data units...')
+        self.run.log_message_with_code('GENERATING_DATA_UNITS')
 
         client = self.run.client
         generated_data_units = []
@@ -804,7 +1000,7 @@ class UploadAction(Action):
                     )
             except Exception as e:
                 failed_count += len(batch)
-                self.run.log_message(f'Failed to create data units batch: {str(e)}')
+                self.run.log_message_with_code('DATA_UNIT_BATCH_FAILED', str(e))
                 for _ in batch:
                     self.run.log_data_unit(None, UploadStatus.FAILED, data_unit_meta=None)
 
@@ -862,14 +1058,15 @@ class UploadAction(Action):
                 type_dirs[spec_name] = spec_dir
 
         if type_dirs:
-            self.run.log_message(f'Found type directories: {list(type_dirs.keys())}')
+            self.run.log_message_with_code('TYPE_DIRECTORIES_FOUND', list(type_dirs.keys()))
 
         # If type-based directories don't exist, exit early
         if not type_dirs:
-            self.run.log_message('No type-based directory structure found.', context=Context.INFO.value)
+            self.run.log_message_with_code('NO_TYPE_DIRECTORIES')
             return organized_files
 
-        self.run.log_message('Detected type-based directory structure')
+        self.run.log_message_with_code('TYPE_STRUCTURE_DETECTED')
+        self.run.log_message_with_code('FILE_ORGANIZATION_STARTED', str(directory))
 
         # Collect and process files in a single pass
         dataset_files = {}
@@ -894,10 +1091,10 @@ class UploadAction(Action):
                             dataset_files[file_name][spec_name] = file_path
 
         if not dataset_files:
-            self.run.log_message('No files found.', context=Context.WARNING.value)
+            self.run.log_message_with_code('NO_FILES_FOUND_WARNING')
             return organized_files
 
-        self.run.log_message(f'Discovered {len(dataset_files)} files')
+        self.run.log_message_with_code('FILES_DISCOVERED', len(dataset_files))
 
         # Organize datasets - check requirements and create metadata
         for file_name, files_dict in sorted(dataset_files.items()):
@@ -926,13 +1123,24 @@ class UploadAction(Action):
                 organized_files.append({'files': files_dict, 'meta': meta_data})
             else:
                 missing = [req for req in required_specs if req not in files_dict]
-                self.run.log_message(
-                    f'{file_name} missing required files: {", ".join(missing)}',
-                    context=Context.WARNING.value,
-                )
+                self.run.log_message_with_code('MISSING_REQUIRED_FILES', file_name, ', '.join(missing))
 
         return organized_files
 
+    def _cleanup_temp_directory(self, temp_path: Optional[Path] = None) -> None:
+        """Clean up temporary directory.
+
+        Args:
+            temp_path (Optional[Path]): Path to temporary directory.
+                If None, uses default temp directory in current working directory.
+        """
+        if temp_path is None:
+            temp_path = Path(os.getcwd()) / 'temp'
+
+        if temp_path.exists():
+            shutil.rmtree(temp_path, ignore_errors=True)
+            self.run.log_message(f'Cleaned up temporary directory: {temp_path}')
+
     def _update_metrics(self, total_count: int, success_count: int, failed_count: int, category: str):
         """Update metrics for upload progress.
 

synapse_sdk/utils/network.py

@@ -1,5 +1,277 @@
+import asyncio
+import queue as queue_module
+import re
+import ssl
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Any, Dict, Generator, Optional
 from urllib.parse import urlparse, urlunparse
 
+import requests
+
+from synapse_sdk.clients.exceptions import ClientError
+
+
+@dataclass
+class StreamLimits:
+    """Configuration for streaming limits."""
+
+    max_messages: int = 10000
+    max_lines: int = 50000
+    max_bytes: int = 50 * 1024 * 1024  # 50MB
+    max_message_size: int = 10240  # 10KB
+    queue_size: int = 1000
+    exception_queue_size: int = 10
+
+
+def validate_resource_id(resource_id: Any, resource_name: str = 'resource') -> str:
+    """Validate resource ID to prevent injection attacks."""
+    if not resource_id:
+        raise ClientError(400, f'{resource_name} ID cannot be empty')
+
+    # Allow numeric IDs and UUID formats
+    id_str = str(resource_id)
+    if not re.match(r'^[a-zA-Z0-9\-_]+$', id_str):
+        raise ClientError(400, f'Invalid {resource_name} ID format')
+
+    if len(id_str) > 100:
+        raise ClientError(400, f'{resource_name} ID too long')
+
+    return id_str
+
+
+def validate_timeout(timeout: Any, max_timeout: int = 300) -> float:
+    """Validate timeout value with bounds checking."""
+    if not isinstance(timeout, (int, float)) or timeout <= 0:
+        raise ClientError(400, 'Timeout must be a positive number')
+
+    if timeout > max_timeout:
+        raise ClientError(400, f'Timeout cannot exceed {max_timeout} seconds')
+
+    return float(timeout)
+
+
+def sanitize_error_message(error_msg: str, context: str = '') -> str:
+    """Sanitize error messages to prevent information disclosure."""
+    sanitized = str(error_msg)[:100]
+    # Remove any potential sensitive information
+    sanitized = re.sub(r'["\']([^"\']*)["\']', '"[REDACTED]"', sanitized)
+
+    if context:
+        return f'{context}: {sanitized}'
+    return sanitized
+
+
+def http_to_websocket_url(url: str) -> str:
+    """Convert HTTP/HTTPS URL to WebSocket URL safely."""
+    try:
+        parsed = urlparse(url)
+        if parsed.scheme == 'http':
+            ws_scheme = 'ws'
+        elif parsed.scheme == 'https':
+            ws_scheme = 'wss'
+        else:
+            raise ClientError(400, f'Invalid URL scheme: {parsed.scheme}')
+
+        ws_url = urlunparse((ws_scheme, parsed.netloc, parsed.path, parsed.params, parsed.query, parsed.fragment))
+        return ws_url
+    except Exception as e:
+        raise ClientError(400, f'Invalid URL format: {str(e)[:50]}')
+
+
+def check_library_available(library_name: str) -> bool:
+    """Check if optional library is available."""
+    try:
+        __import__(library_name)
+        return True
+    except ImportError:
+        return False
+
+
+class WebSocketStreamManager:
+    """Manages secure WebSocket streaming with rate limiting and error handling."""
+
+    def __init__(self, thread_pool: ThreadPoolExecutor, limits: Optional[StreamLimits] = None):
+        self.thread_pool = thread_pool
+        self.limits = limits or StreamLimits()
+
+    def stream_logs(
+        self, ws_url: str, headers: Dict[str, str], timeout: float, context: str
+    ) -> Generator[str, None, None]:
+        """Stream logs from WebSocket with proper error handling and cleanup."""
+        if not check_library_available('websockets'):
+            raise ClientError(500, 'websockets library not available for WebSocket connections')
+
+        try:
+            import websockets
+
+            # Use bounded queues to prevent memory exhaustion
+            message_queue = queue_module.Queue(maxsize=self.limits.queue_size)
+            exception_queue = queue_module.Queue(maxsize=self.limits.exception_queue_size)
+
+            async def websocket_client():
+                try:
+                    # Add SSL verification and proper timeouts
+                    connect_kwargs = {
+                        'extra_headers': headers,
+                        'close_timeout': timeout,
+                        'ping_timeout': timeout,
+                        'ping_interval': timeout // 2,
+                    }
+
+                    # For secure connections, add SSL context
+                    if ws_url.startswith('wss://'):
+                        ssl_context = ssl.create_default_context()
+                        ssl_context.check_hostname = True
+                        ssl_context.verify_mode = ssl.CERT_REQUIRED
+                        connect_kwargs['ssl'] = ssl_context
+
+                    async with websockets.connect(ws_url, **connect_kwargs) as websocket:
+                        message_count = 0
+
+                        async for message in websocket:
+                            message_count += 1
+                            if message_count > self.limits.max_messages:
+                                exception_queue.put_nowait(ClientError(429, f'Message limit exceeded for {context}'))
+                                break
+
+                            # Validate message size
+                            if len(str(message)) > self.limits.max_message_size:
+                                continue
+
+                            try:
+                                message_queue.put_nowait(f'{message}\n')
+                            except queue_module.Full:
+                                exception_queue.put_nowait(ClientError(429, f'Message queue full for {context}'))
+                                break
+
+                        message_queue.put_nowait(None)  # Signal end
+
+                except websockets.exceptions.ConnectionClosed:
+                    exception_queue.put_nowait(ClientError(503, f'WebSocket connection closed for {context}'))
+                except asyncio.TimeoutError:
+                    exception_queue.put_nowait(ClientError(408, f'WebSocket timed out for {context}'))
+                except Exception as e:
+                    sanitized_error = sanitize_error_message(str(e), context)
+                    exception_queue.put_nowait(ClientError(500, sanitized_error))
+
+            # Use thread pool instead of raw threading
+            future = self.thread_pool.submit(lambda: asyncio.run(websocket_client()))
+
+            # Yield messages with proper cleanup
+            try:
+                while True:
+                    # Check for exceptions first
+                    try:
+                        exception = exception_queue.get_nowait()
+                        raise exception
+                    except queue_module.Empty:
+                        pass
+
+                    # Get message with timeout
+                    try:
+                        message = message_queue.get(timeout=1.0)
+                        if message is None:  # End signal
+                            break
+                        yield message
+                    except queue_module.Empty:
+                        # Check if future is done
+                        if future.done():
+                            try:
+                                future.result()  # This will raise any exception
+                                break  # Normal completion
+                            except Exception:
+                                break  # Error already in queue
+                        continue
+
+            finally:
+                # Cleanup: cancel future if still running
+                if not future.done():
+                    future.cancel()
+
+        except ImportError:
+            raise ClientError(500, 'websockets library not available for WebSocket connections')
+        except Exception as e:
+            if isinstance(e, ClientError):
+                raise
+            sanitized_error = sanitize_error_message(str(e), context)
+            raise ClientError(500, sanitized_error)
+
+
+class HTTPStreamManager:
+    """Manages HTTP streaming with rate limiting and proper resource cleanup."""
+
+    def __init__(self, requests_session: requests.Session, limits: Optional[StreamLimits] = None):
+        self.requests_session = requests_session
+        self.limits = limits or StreamLimits()
+
+    def stream_logs(
+        self, url: str, headers: Dict[str, str], timeout: tuple, context: str
+    ) -> Generator[str, None, None]:
+        """Stream logs from HTTP endpoint with proper error handling and cleanup."""
+        response = None
+        try:
+            # Use timeout for streaming to prevent hanging
+            response = self.requests_session.get(url, headers=headers, stream=True, timeout=timeout)
+            response.raise_for_status()
+
+            # Set up streaming with timeout and size limits
+            line_count = 0
+            total_bytes = 0
+
+            try:
+                for line in response.iter_lines(decode_unicode=True, chunk_size=1024):
+                    if line:
+                        line_count += 1
+                        total_bytes += len(line.encode('utf-8'))
+
+                        # Rate limiting checks
+                        if line_count > self.limits.max_lines:
+                            raise ClientError(429, f'Line limit exceeded for {context}')
+
+                        if total_bytes > self.limits.max_bytes:
+                            raise ClientError(429, f'Size limit exceeded for {context}')
+
+                        # Validate line size
+                        if len(line) > self.limits.max_message_size:
+                            continue
+
+                        yield f'{line}\n'
+
+            except requests.exceptions.ChunkedEncodingError:
+                raise ClientError(503, f'Log stream interrupted for {context}')
+            except requests.exceptions.ReadTimeout:
+                raise ClientError(408, f'Log stream timed out for {context}')
+
+        except requests.exceptions.ConnectTimeout:
+            raise ClientError(408, f'Failed to connect to log stream for {context}')
+        except requests.exceptions.ReadTimeout:
+            raise ClientError(408, f'Log stream read timeout for {context}')
+        except requests.exceptions.ConnectionError as e:
+            if 'Connection refused' in str(e):
+                raise ClientError(503, f'Agent connection refused for {context}')
+            else:
+                sanitized_error = sanitize_error_message(str(e), context)
+                raise ClientError(503, f'Agent connection error: {sanitized_error}')
+        except requests.exceptions.HTTPError as e:
+            if hasattr(e.response, 'status_code'):
+                status_code = e.response.status_code
+            else:
+                status_code = 500
+            raise ClientError(status_code, f'HTTP error streaming logs for {context}')
+        except Exception as e:
+            if isinstance(e, ClientError):
+                raise
+            sanitized_error = sanitize_error_message(str(e), context)
+            raise ClientError(500, sanitized_error)
+        finally:
+            # Ensure response is properly closed
+            if response is not None:
+                try:
+                    response.close()
+                except Exception:
+                    pass  # Ignore cleanup errors
+
 
 def clean_url(url, remove_query_params=True, remove_fragment=True):
     parsed = urlparse(url)

{synapse_sdk-1.0.0b8.dist-info → synapse_sdk-1.0.0b10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0b8
+Version: 1.0.0b10
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT
@@ -22,6 +22,7 @@ Requires-Dist: universal-pathlib
 Requires-Dist: fsspec[gcs,s3,sftp]
 Requires-Dist: inquirer
 Requires-Dist: pillow
+Requires-Dist: websockets
 Provides-Extra: all
 Requires-Dist: ray[all]==2.44.1; extra == "all"
 Requires-Dist: python-nmap; extra == "all"

{synapse_sdk-1.0.0b8.dist-info → synapse_sdk-1.0.0b10.dist-info}/RECORD

@@ -29,7 +29,7 @@ synapse_sdk/clients/exceptions.py,sha256=ylv7x10eOp4aA3a48jwonnvqvkiYwzJYXjkVkRT
 synapse_sdk/clients/utils.py,sha256=8pPJTdzHiRPSbZMoQYHAgR2BAMO6u_R_jMV6a2p34iQ,392
 synapse_sdk/clients/agent/__init__.py,sha256=FqYbtzMJdzRfuU2SA-Yxdc0JKmVP1wxH6OlUNmB4lH8,2230
 synapse_sdk/clients/agent/core.py,sha256=aeMSzf8BF7LjVcmHaL8zC7ofBZUff8kIeqkW1xUJ6Sk,745
-synapse_sdk/clients/agent/ray.py,sha256=1EDl-bMN2CvKl07-qMidSWNOGpvIvzcWl7jDBCza65o,3248
+synapse_sdk/clients/agent/ray.py,sha256=LRLX0ypz9qe6e8F4O8ffyhSMlvSfupz5gUzI1yIZYrw,11978
 synapse_sdk/clients/agent/service.py,sha256=s7KuPK_DB1nr2VHrigttV1WyFonaGHNrPvU8loRxHcE,478
 synapse_sdk/clients/backend/__init__.py,sha256=9FzjQn0ljRhtdaoG3n38Mdgte7GFwIh4OtEmoqVg2_E,2098
 synapse_sdk/clients/backend/annotation.py,sha256=4MfX_ubDw6UxU_TFEWLqjqOT1lS8RYD29f5bJs0TfF4,1245
@@ -53,7 +53,7 @@ synapse_sdk/devtools/docs/README.md,sha256=yBzWf0K1ef4oymFXDaHo0nYWEgMQJqsOyrkNh
 synapse_sdk/devtools/docs/docusaurus.config.ts,sha256=zH1dxP4hmKsYWTo1OYMBIeE0Cj5dC8KChVtkORNQB5E,3129
 synapse_sdk/devtools/docs/package-lock.json,sha256=FfI_0BxNDB3tupLYxsH2PY4ogaBL6p22ujFWy8rRu88,653289
 synapse_sdk/devtools/docs/package.json,sha256=9UcQc49bh7CM1e8Cc4XYPWxRvHaZSXkecheWIC8Aohk,1144
-synapse_sdk/devtools/docs/sidebars.ts,sha256=Yd6ccVA8HaNaUuQa8H37BPu5PDw-bmhbiZJnv4bmQz4,996
+synapse_sdk/devtools/docs/sidebars.ts,sha256=-DteBl5FSI1bdg9eHC__Q3LjcIUGYUhKjVoz9Xpc0u0,1443
 synapse_sdk/devtools/docs/tsconfig.json,sha256=O9BNlRPjPiaVHW2_boShMbmTnh0Z2k0KQO6Alf9FMVY,215
 synapse_sdk/devtools/docs/blog/2019-05-28-first-blog-post.md,sha256=iP7gl_FPqo-qX13lkSRcRoT6ayJNmCkXoyvlm7GH248,312
 synapse_sdk/devtools/docs/blog/2019-05-29-long-blog-post.md,sha256=cM-dhhTeurEWMcdn0Kx-NpNts2YUUraSI_XFk_gVHEE,3122
@@ -141,7 +141,7 @@ synapse_sdk/plugins/categories/post_annotation/templates/plugin/post_annotation.
 synapse_sdk/plugins/categories/pre_annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/pre_annotation/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/pre_annotation/actions/pre_annotation.py,sha256=6ib3RmnGrjpsQ0e_G-mRH1lfFunQ3gh2M831vuDn7HU,344
-synapse_sdk/plugins/categories/pre_annotation/actions/to_task.py,sha256=x6KPK89OWS7wsmYZ-wFFPhUl_fXEO74NIVB4bUChm6Q,40323
+synapse_sdk/plugins/categories/pre_annotation/actions/to_task.py,sha256=trdlqnBlUSRrAZisnGw-aSxaiMZECSi05zuRyJxfbLQ,40516
 synapse_sdk/plugins/categories/pre_annotation/templates/config.yaml,sha256=VREoCp9wsvZ8T2E1d_MEKlR8TC_herDJGVQtu3ezAYU,589
 synapse_sdk/plugins/categories/pre_annotation/templates/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/pre_annotation/templates/plugin/pre_annotation.py,sha256=HBHxHuv2gMBzDB2alFfrzI_SZ1Ztk6mo7eFbR5GqHKw,106
@@ -154,7 +154,7 @@ synapse_sdk/plugins/categories/smart_tool/templates/plugin/__init__.py,sha256=47
 synapse_sdk/plugins/categories/smart_tool/templates/plugin/auto_label.py,sha256=eevNg0nOcYFR4z_L_R-sCvVOYoLWSAH1jwDkAf3YCjY,320
 synapse_sdk/plugins/categories/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/upload/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-synapse_sdk/plugins/categories/upload/actions/upload.py,sha256=Lhc_ezB_FvkDI7LTe50tadOQ2W9vp2ppTWYNJSWYKfY,38114
+synapse_sdk/plugins/categories/upload/actions/upload.py,sha256=XIKbXqzarSy6Rt41g03pkq0loAkKWBTX4yv47E25_rs,45203
 synapse_sdk/plugins/categories/upload/templates/config.yaml,sha256=6_dRa0_J2aS8NSUfO4MKbPxZcdPS2FpJzzp51edYAZc,281
 synapse_sdk/plugins/categories/upload/templates/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 synapse_sdk/plugins/categories/upload/templates/plugin/upload.py,sha256=IZU4sdSMSLKPCtlNqF7DP2howTdYR6hr74HCUZsGdPk,1559
@@ -184,7 +184,7 @@ synapse_sdk/utils/encryption.py,sha256=KMARrAk5aIHfBLC8CvdXiSIuaGvxljluubjF9PVLf
 synapse_sdk/utils/file.py,sha256=wWBQAx0cB5a-fjfRMeJV-KjBil1ZyKRz-vXno3xBSoo,6834
 synapse_sdk/utils/http.py,sha256=yRxYfru8tMnBVeBK-7S0Ga13yOf8oRHquG5e8K_FWcI,4759
 synapse_sdk/utils/module_loading.py,sha256=chHpU-BZjtYaTBD_q0T7LcKWtqKvYBS4L0lPlKkoMQ8,1020
-synapse_sdk/utils/network.py,sha256=WI8qn6KlKpHdMi45V57ofKJB8zusJrbQsxT74LwVfsY,1000
+synapse_sdk/utils/network.py,sha256=4zWUbuEPcMXb_NVVeuUJ8zSl10ZAlWVHfzqbR25aez8,11978
 synapse_sdk/utils/string.py,sha256=rEwuZ9SAaZLcQ8TYiwNKr1h2u4CfnrQx7SUL8NWmChg,216
 synapse_sdk/utils/converters/__init__.py,sha256=xQi_n7xS9BNyDiolsxH2jw1CtD6avxMPj2cHnwvidi8,11311
 synapse_sdk/utils/converters/coco/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -211,9 +211,9 @@ synapse_sdk/utils/storage/providers/gcp.py,sha256=i2BQCu1Kej1If9SuNr2_lEyTcr5M_n
 synapse_sdk/utils/storage/providers/http.py,sha256=2DhIulND47JOnS5ZY7MZUex7Su3peAPksGo1Wwg07L4,5828
 synapse_sdk/utils/storage/providers/s3.py,sha256=ZmqekAvIgcQBdRU-QVJYv1Rlp6VHfXwtbtjTSphua94,2573
 synapse_sdk/utils/storage/providers/sftp.py,sha256=_8s9hf0JXIO21gvm-JVS00FbLsbtvly4c-ETLRax68A,1426
-synapse_sdk-1.0.0b8.dist-info/licenses/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
-synapse_sdk-1.0.0b8.dist-info/METADATA,sha256=ket2lKeDpD9UdZRjFcA-WoJBJwEAFt1yT1YPuaDOXKo,3718
-synapse_sdk-1.0.0b8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-synapse_sdk-1.0.0b8.dist-info/entry_points.txt,sha256=VNptJoGoNJI8yLXfBmhgUefMsmGI0m3-0YoMvrOgbxo,48
-synapse_sdk-1.0.0b8.dist-info/top_level.txt,sha256=ytgJMRK1slVOKUpgcw3LEyHHP7S34J6n_gJzdkcSsw8,12
-synapse_sdk-1.0.0b8.dist-info/RECORD,,
+synapse_sdk-1.0.0b10.dist-info/licenses/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
+synapse_sdk-1.0.0b10.dist-info/METADATA,sha256=SbK-qGKAO8WGswV_JGf0qJVFBPfC_f6dx0I6o46MDlQ,3745
+synapse_sdk-1.0.0b10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+synapse_sdk-1.0.0b10.dist-info/entry_points.txt,sha256=VNptJoGoNJI8yLXfBmhgUefMsmGI0m3-0YoMvrOgbxo,48
+synapse_sdk-1.0.0b10.dist-info/top_level.txt,sha256=ytgJMRK1slVOKUpgcw3LEyHHP7S34J6n_gJzdkcSsw8,12
+synapse_sdk-1.0.0b10.dist-info/RECORD,,