synapse-sdk 1.0.0b6__tar.gz → 1.0.0b8__tar.gz

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8}/.gitignore

@@ -49,6 +49,9 @@ CLAUDE.local.md
 GEMINI.local.md
 AGENT.local.md
 
+# Specs for LLM development
+specs/*.local.md
+
 # Claude
 settings.local.json
 

{synapse_sdk-1.0.0b6/synapse_sdk.egg-info → synapse_sdk-1.0.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0b6
+Version: 1.0.0b8
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8}/docs/cli-usage.md

@@ -231,7 +231,7 @@ synapse plugin publish [OPTIONS]
 
 2. **Workspace Paths**: Agent workspaces typically use `/home/coder/workspace` - this is normal for containerized environments.
 
-3. **Port Configuration**: Local code-server port is read from your config file, defaulting to 8880 if not configured.
+3. **Port Configuration**: Local code-server port is read from your config file, defaulting to 8070 if not configured.
 
 ### Configuration Management
 

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8}/docs/faq.md

@@ -54,12 +54,12 @@ This opens the interactive menu where you can access all Synapse features.
 
 ### Q: How do I configure the code-server port?
 
-Code-server port is automatically detected from `~/.config/code-server/config.yaml`. If no config exists, it defaults to port 8880.
+Code-server port is automatically detected from `~/.config/code-server/config.yaml`. If no config exists, it defaults to port 8070.
 
 Example config:
 
 ```yaml
-bind-addr: 127.0.0.1:8880
+bind-addr: 127.0.0.1:8070
 auth: password
 password: your-password-here
 cert: false

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8}/docs/features/converters/index.md

@@ -12,19 +12,20 @@ The Synapse SDK provides comprehensive data format conversion utilities for comp
 
 The converter system supports bidirectional conversion between:
 
-- **DM Format** - Synapse Data Manager's native annotation format
-- **COCO Format** - Microsoft Common Objects in Context format
+- **DM Format** - Synapse Data Manager's native annotation format (supports v1 ⟷ v2 migration)
+- **COCO Format** - Microsoft Common Objects in Context format  
 - **Pascal VOC Format** - Visual Object Classes XML format
 - **YOLO Format** - You Only Look Once text-based format
 
-All converters support both categorized datasets (with train/valid/test splits) and non-categorized datasets.
+All converters support both categorized datasets (with train/valid/test splits) and non-categorized datasets. Additionally, all converters now support single file conversion mode for processing individual files.
 
 ## Supported Annotation Types
 
 | Annotation Type | DM | COCO | Pascal VOC | YOLO |
 |----------------|----|----|-----------|------|
 | Bounding Boxes | ✅ | ✅ | ✅ | ✅ |
-| Polygons/Segmentation | ✅ | ✅ | ❌ | ✅ |
+| Polygons | ✅ | ✅ | ❌ | ✅ |
+| Segmentation | ✅ | ✅ | ✅ | ❌ |
 | Keypoints | ✅ | ✅ | ❌ | ✅ |
 | Classifications | ✅ | ✅ | ❌ | ❌ |
 
@@ -35,7 +36,7 @@ All converters support both categorized datasets (with train/valid/test splits)
 Converts DM format annotations to Pascal VOC XML format.
 
 **Features:**
-- Converts bounding box annotations only
+- Converts bounding box annotations and segmentation masks
 - Creates standard Pascal VOC directory structure
 - Generates `classes.txt` file automatically
 - Supports both categorized and non-categorized datasets
@@ -59,6 +60,13 @@ converter = FromDMToPascalConverter(
 )
 converted_data = converter.convert()
 converter.save_to_folder('/output/pascal/dataset')
+
+# Single file conversion
+converter = FromDMToPascalConverter(is_single_conversion=True)
+with open('data.json') as f:
+    dm_data = json.load(f)
+with open('image.jpg', 'rb') as img_file:
+    pascal_xml = converter.convert_single_file(dm_data, img_file)
 ```
 
 **Input Structure (Categorized):**
@@ -101,7 +109,7 @@ Converts Pascal VOC XML annotations to DM format.
 **Features:**
 - Parses Pascal VOC XML files
 - Flexible directory naming (supports Annotations/annotations, Images/images/JPEGImages)
-- Extracts bounding box annotations only
+- Extracts bounding box annotations and segmentation information
 - Maintains class information
 
 **Usage:**
@@ -140,6 +148,13 @@ converter = FromDMToYOLOConverter(
 )
 converted_data = converter.convert()
 converter.save_to_folder('/output/yolo/dataset')
+
+# Single file conversion
+converter = FromDMToYOLOConverter(is_single_conversion=True)
+with open('data.json') as f:
+    dm_data = json.load(f)
+with open('image.jpg', 'rb') as img_file:
+    yolo_labels = converter.convert_single_file(dm_data, img_file)
 ```
 
 **Output Structure:**
@@ -200,7 +215,7 @@ Converts DM format to COCO format with full metadata support.
 
 **Features:**
 - Comprehensive COCO metadata (info, licenses, categories)
-- Supports bounding boxes, segmentation, and keypoints
+- Supports bounding boxes, polygons, segmentation, and keypoints
 - Dynamic category management
 - Extensible for different data types
 
@@ -235,6 +250,16 @@ converter = FromDMToCOCOConverter(
     licenses_list=licenses_list,
     is_categorized_dataset=True
 )
+
+# Single file conversion
+converter = FromDMToCOCOConverter(
+    data_type='img',
+    is_single_conversion=True
+)
+with open('data.json') as f:
+    dm_data = json.load(f)
+with open('image.jpg', 'rb') as img_file:
+    coco_annotation = converter.convert_single_file(dm_data, img_file)
 ```
 
 **Output Structure:**
@@ -347,17 +372,24 @@ with open('dm_v1_data.json', 'w') as f:
 All converters share these common parameters:
 
 ### `root_dir` (str)
-Path to the root directory containing the dataset.
+Path to the root directory containing the dataset. Not required when using single file conversion mode.
 
 ### `is_categorized_dataset` (bool)
 - `True`: Dataset has train/valid/test splits in separate subdirectories
 - `False`: Dataset is in a single directory without splits
 
+### `is_single_conversion` (bool)
+- `True`: Enable single file conversion mode for processing individual files
+- `False`: Process entire dataset directories (default behavior)
+
 ### Common Methods
 
 #### `convert()`
 Performs in-memory conversion and returns the converted data structure.
 
+#### `convert_single_file(data, original_file, **kwargs)`
+Available when `is_single_conversion=True`. Converts a single data object and corresponding original file.
+
 #### `save_to_folder(output_dir)`
 Saves the converted data to the specified output directory, creating the appropriate file structure for the target format.
 
@@ -399,4 +431,25 @@ coco_data = coco_converter.convert()
 coco_converter.save_to_folder('/data/coco_eval')
 ```
 
+### Single File Conversion Example
+
+```python
+import json
+from synapse_sdk.utils.converters.yolo.from_dm import FromDMToYOLOConverter
+
+# Initialize converter for single file processing
+converter = FromDMToYOLOConverter(is_single_conversion=True)
+
+# Load DM format data
+with open('annotation.json', 'r') as f:
+    dm_data = json.load(f)
+
+# Convert single file
+with open('image.jpg', 'rb') as img_file:
+    yolo_labels = converter.convert_single_file(dm_data, img_file)
+
+# yolo_labels contains the converted YOLO format labels
+print(yolo_labels)
+```
+
 This converter system provides a complete solution for dataset format transformation, enabling seamless integration between different machine learning workflows and annotation tools.

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8}/synapse_sdk/cli/code_server.py

@@ -2,7 +2,9 @@
 
 import os
 import shutil
+import socket
 import subprocess
+import webbrowser
 from pathlib import Path
 from typing import Optional
 from urllib.parse import quote
@@ -141,6 +143,169 @@ def detect_and_encrypt_plugin(workspace_path: str) -> Optional[dict]:
         return None
 
 
+def is_ssh_session() -> bool:
+    """Check if we're in an SSH session.
+
+    Returns:
+        bool: True if in SSH session, False otherwise
+    """
+    return bool(os.environ.get('SSH_CONNECTION') or os.environ.get('SSH_CLIENT'))
+
+
+def is_vscode_terminal() -> bool:
+    """Check if we're running in a VSCode terminal.
+
+    Returns:
+        bool: True if in VSCode terminal, False otherwise
+    """
+    return os.environ.get('TERM_PROGRAM') == 'vscode'
+
+
+def is_vscode_ssh_session() -> bool:
+    """Check if we're in a VSCode terminal over SSH.
+
+    Returns:
+        bool: True if in VSCode terminal via SSH, False otherwise
+    """
+    return is_vscode_terminal() and is_ssh_session()
+
+
+def get_ssh_tunnel_instructions(port: int) -> str:
+    """Get SSH tunnel setup instructions for VSCode users.
+
+    Args:
+        port: The port number code-server is running on
+
+    Returns:
+        str: Instructions for setting up SSH tunnel
+    """
+    ssh_client = os.environ.get('SSH_CLIENT', '').split()[0] if os.environ.get('SSH_CLIENT') else 'your_server'
+
+    instructions = f"""
+📡 VSCode SSH Tunnel Setup:
+
+Since you're using VSCode's integrated terminal over SSH, you can access code-server locally by:
+
+1. Using VSCode's built-in port forwarding:
+   • Open Command Palette (Cmd/Ctrl+Shift+P)
+   • Type "Forward a Port"
+   • Enter port: {port}
+   • VSCode will automatically forward the port
+
+2. Or manually forward the port in a new local terminal:
+   ssh -L {port}:localhost:{port} {ssh_client}
+
+3. Then open in your local browser:
+   http://localhost:{port}
+"""
+    return instructions
+
+
+def open_browser_smart(url: str) -> bool:
+    """Open browser with smart fallback handling.
+
+    Attempts to open a browser using multiple methods, with appropriate
+    handling for SSH sessions and headless environments.
+
+    Args:
+        url: URL to open
+
+    Returns:
+        bool: True if browser was opened successfully, False otherwise
+    """
+    # Don't even try to open browser in SSH sessions (except VSCode can handle it)
+    if is_ssh_session() and not is_vscode_terminal():
+        return False
+
+    # Try Python's webbrowser module first (cross-platform)
+    try:
+        if webbrowser.open(url):
+            return True
+    except Exception:
+        pass
+
+    # Try platform-specific commands
+    commands = []
+
+    # Check for macOS
+    if shutil.which('open'):
+        commands.append(['open', url])
+
+    # Check for Linux with display
+    if os.environ.get('DISPLAY'):
+        if shutil.which('xdg-open'):
+            commands.append(['xdg-open', url])
+        if shutil.which('gnome-open'):
+            commands.append(['gnome-open', url])
+        if shutil.which('kde-open'):
+            commands.append(['kde-open', url])
+
+    # Try each command
+    for cmd in commands:
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=2)
+            if result.returncode == 0:
+                return True
+        except Exception:
+            continue
+
+    return False
+
+
+def is_port_in_use(port: int) -> bool:
+    """Check if a port is already in use.
+
+    Args:
+        port: Port number to check
+
+    Returns:
+        bool: True if port is in use, False otherwise
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.bind(('127.0.0.1', port))
+            return False
+        except socket.error:
+            return True
+
+
+def get_process_on_port(port: int) -> Optional[str]:
+    """Get the name of the process using a specific port.
+
+    Args:
+        port: Port number to check
+
+    Returns:
+        str: Process name if found, None otherwise
+    """
+    try:
+        # Use lsof to find the process
+        result = subprocess.run(['lsof', '-i', f':{port}', '-t'], capture_output=True, text=True, timeout=2)
+
+        if result.returncode == 0 and result.stdout.strip():
+            # Get the PID
+            pid = result.stdout.strip().split('\n')[0]
+
+            # Get process details
+            proc_result = subprocess.run(['ps', '-p', pid, '-o', 'comm='], capture_output=True, text=True, timeout=2)
+
+            if proc_result.returncode == 0:
+                process_name = proc_result.stdout.strip()
+                # Check if it's a code-server process
+                if 'node' in process_name or 'code-server' in process_name:
+                    # Try to get more details
+                    cmd_result = subprocess.run(
+                        ['ps', '-p', pid, '-o', 'args='], capture_output=True, text=True, timeout=2
+                    )
+                    if cmd_result.returncode == 0 and 'code-server' in cmd_result.stdout:
+                        return 'code-server'
+                return process_name
+    except Exception:
+        pass
+
+    return None
+
+
 def is_code_server_installed() -> bool:
     """Check if code-server is installed locally.
 
@@ -154,7 +319,7 @@ def get_code_server_port() -> int:
     """Get code-server port from config file.
 
     Returns:
-        int: Port number from config, defaults to 8880 if not found
+        int: Port number from config, defaults to 8070 if not found
     """
     config_path = Path.home() / '.config' / 'code-server' / 'config.yaml'
 
@@ -163,7 +328,7 @@ def get_code_server_port() -> int:
             with open(config_path, 'r') as f:
                 config = yaml.safe_load(f)
 
-            # Parse bind-addr which can be in format "127.0.0.1:8880" or just ":8880"
+            # Parse bind-addr which can be in format "127.0.0.1:8070" or just ":8070"
             bind_addr = config.get('bind-addr', '')
             if ':' in bind_addr:
                 port_str = bind_addr.split(':')[-1]
@@ -176,31 +341,133 @@ def get_code_server_port() -> int:
         pass
 
     # Default port if config not found or invalid
-    return 8880
+    return 8070
 
 
-def launch_local_code_server(workspace_path: str, open_browser: bool = True) -> None:
+def launch_local_code_server(workspace_path: str, open_browser: bool = True, custom_port: Optional[int] = None) -> None:
     """Launch local code-server instance.
 
     Args:
         workspace_path: Directory to open in code-server
         open_browser: Whether to open browser automatically
+        custom_port: Optional custom port to use instead of config/default
     """
     try:
-        # Get port from config
-        port = get_code_server_port()
+        # Use custom port if provided, otherwise get from config
+        port = custom_port if custom_port else get_code_server_port()
+
+        # Check if port is already in use
+        if is_port_in_use(port):
+            process_name = get_process_on_port(port)
+
+            if process_name == 'code-server':
+                # Code-server is already running
+                click.echo(f'⚠️  Code-server is already running on port {port}')
+
+                # Create URL with folder query parameter
+                encoded_path = quote(workspace_path)
+                url_with_folder = f'http://localhost:{port}/?folder={encoded_path}'
+
+                # Ask user what to do
+                questions = [
+                    inquirer.List(
+                        'action',
+                        message='What would you like to do?',
+                        choices=[
+                            ('Use existing code-server instance', 'use_existing'),
+                            ('Stop existing and start new instance', 'restart'),
+                            ('Cancel', 'cancel'),
+                        ],
+                    )
+                ]
+
+                try:
+                    answers = inquirer.prompt(questions)
+
+                    if not answers or answers['action'] == 'cancel':
+                        click.echo('Cancelled')
+                        return
+
+                    if answers['action'] == 'use_existing':
+                        click.echo('\n✅ Using existing code-server instance')
+                        click.echo(f'   URL: {url_with_folder}')
+
+                        # Optionally open browser
+                        if open_browser:
+                            if is_vscode_ssh_session():
+                                # Special handling for VSCode SSH sessions
+                                click.echo(get_ssh_tunnel_instructions(port))
+                                click.echo(f'🔗 Remote URL: {url_with_folder}')
+                                click.echo(f'\n✨ After port forwarding, access at: http://localhost:{port}')
+                            elif is_ssh_session():
+                                click.echo('📝 SSH session detected - please open the URL in your local browser')
+                                click.echo(f'👉 URL: {url_with_folder}')
+                            elif open_browser_smart(url_with_folder):
+                                click.echo('✅ Browser opened successfully')
+                            else:
+                                click.echo('⚠️  Could not open browser automatically')
+                                click.echo(f'👉 URL: {url_with_folder}')
+                        return
+
+                    if answers['action'] == 'restart':
+                        # Stop existing code-server
+                        click.echo('Stopping existing code-server...')
+                        try:
+                            # Get PID of code-server process
+                            result = subprocess.run(
+                                ['lsof', '-i', f':{port}', '-t'], capture_output=True, text=True, timeout=2
+                            )
+
+                            if result.returncode == 0 and result.stdout.strip():
+                                pid = result.stdout.strip().split('\n')[0]
+                                subprocess.run(['kill', pid], timeout=5)
+
+                                # Wait a moment for process to stop
+                                import time
+
+                                time.sleep(2)
+
+                                click.echo('✅ Existing code-server stopped')
+                        except Exception as e:
+                            click.echo(f'⚠️  Could not stop existing code-server: {e}')
+                            click.echo('Please stop it manually and try again')
+                            return
+
+                except (KeyboardInterrupt, EOFError):
+                    click.echo('\nCancelled')
+                    return
+
+            else:
+                # Another process is using the port
+                click.echo(f'❌ Port {port} is already in use by: {process_name or "unknown process"}')
+                if not custom_port:
+                    click.echo('\nYou can:')
+                    click.echo('1. Stop the process using the port')
+                    click.echo('2. Use a different port with --port option (e.g., --port 8071)')
+                    click.echo('3. Change the default port in ~/.config/code-server/config.yaml')
+                else:
+                    click.echo(f'Please try a different port or stop the process using port {port}')
+                return
 
         # Create URL with folder query parameter
         encoded_path = quote(workspace_path)
         url_with_folder = f'http://localhost:{port}/?folder={encoded_path}'
 
         # Basic code-server command - let code-server handle the workspace internally
-        cmd = ['code-server', workspace_path]
+        cmd = ['code-server']
+
+        # Add custom port binding if specified
+        if custom_port:
+            cmd.extend(['--bind-addr', f'127.0.0.1:{port}'])
+
+        cmd.append(workspace_path)
 
         if not open_browser:
             cmd.append('--disable-getting-started-override')
 
         click.echo(f'🚀 Starting local code-server for workspace: {workspace_path}')
+        if custom_port:
+            click.echo(f'   Using custom port: {port}')
         click.echo(f'   URL: {url_with_folder}')
         click.echo('   Press Ctrl+C to stop the server')
 
@@ -221,17 +488,18 @@ def launch_local_code_server(workspace_path: str, open_browser: bool = True) ->
             time.sleep(3)
 
             # Open browser with folder parameter
-            try:
-                result = subprocess.run(['xdg-open', url_with_folder], capture_output=True, text=True, timeout=2)
-                if result.returncode != 0:
-                    click.echo('⚠️  Could not open browser automatically (no display?)')
-                    click.echo(f'👉 Please manually open: {url_with_folder}')
-                else:
-                    click.echo('✅ Browser opened successfully')
-            except (subprocess.TimeoutExpired, FileNotFoundError):
-                click.echo('⚠️  Could not open browser (headless environment)')
-                click.echo(f'👉 Please manually open: {url_with_folder}')
-            except Exception:
+            if is_vscode_ssh_session():
+                # Special handling for VSCode SSH sessions
+                click.echo(get_ssh_tunnel_instructions(port))
+                click.echo(f'🔗 Remote URL: {url_with_folder}')
+                click.echo(f'\n✨ After port forwarding, access at: http://localhost:{port}')
+            elif is_ssh_session():
+                click.echo('📝 SSH session detected - please open the URL in your local browser')
+                click.echo(f'👉 URL: {url_with_folder}')
+            elif open_browser_smart(url_with_folder):
+                click.echo('✅ Browser opened successfully')
+            else:
+                click.echo('⚠️  Could not open browser automatically')
                 click.echo(f'👉 Please manually open: {url_with_folder}')
 
             # Wait for the server thread (blocking)
@@ -333,19 +601,22 @@ def run_agent_code_server(agent: Optional[str], workspace: str, open_browser: bo
     if open_browser and url:
         click.echo('\nAttempting to open in browser...')
 
-        # Try to open browser, suppressing stderr to avoid xdg-open noise
-        try:
-            # Use subprocess to suppress xdg-open errors
-            result = subprocess.run(['xdg-open', url], capture_output=True, text=True, timeout=2)
-            if result.returncode != 0:
-                click.echo('⚠️  Could not open browser automatically (no display?)')
-                click.echo(f'👉 Please manually open: {url}')
-        except (subprocess.TimeoutExpired, FileNotFoundError):
-            # xdg-open not available or timed out
-            click.echo('⚠️  Could not open browser (headless environment)')
-            click.echo(f'👉 Please manually open: {url}')
-        except Exception:
-            # Fallback for other errors
+        if is_vscode_ssh_session():
+            # Extract port from URL for instructions
+            import re
+
+            port_match = re.search(r':(\d+)', url)
+            if port_match:
+                agent_port = int(port_match.group(1))
+                click.echo(get_ssh_tunnel_instructions(agent_port))
+            click.echo(f'🔗 Remote URL: {url}')
+        elif is_ssh_session():
+            click.echo('📝 SSH session detected - please open the URL in your local browser')
+            click.echo(f'👉 URL: {url}')
+        elif open_browser_smart(url):
+            click.echo('✅ Browser opened successfully')
+        else:
+            click.echo('⚠️  Could not open browser automatically')
             click.echo(f'👉 Please manually open: {url}')
 
     # Show additional instructions
@@ -364,7 +635,8 @@ def run_agent_code_server(agent: Optional[str], workspace: str, open_browser: bo
 @click.option('--agent', help='Agent name or ID')
 @click.option('--open-browser/--no-open-browser', default=True, help='Open in browser')
 @click.option('--workspace', help='Workspace directory path (defaults to current directory)')
-def code_server(agent: Optional[str], open_browser: bool, workspace: Optional[str]):
+@click.option('--port', type=int, help='Port to bind code-server (default: from config or 8070)')
+def code_server(agent: Optional[str], open_browser: bool, workspace: Optional[str], port: Optional[int]):
     """Open code-server either through agent or locally."""
 
     # Get current working directory if workspace not specified
@@ -405,7 +677,7 @@ def code_server(agent: Optional[str], open_browser: bool, workspace: Optional[st
 
         elif answers['option'] == 'local':
             click.echo('\n💻 Starting local code-server...')
-            launch_local_code_server(workspace, open_browser)
+            launch_local_code_server(workspace, open_browser, port)
 
         elif answers['option'] == 'install':
             show_code_server_installation_help()

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8}/synapse_sdk/plugins/categories/export/actions/export.py

@@ -41,7 +41,7 @@ class ExportRun(Run):
         """Log export file information.
 
         Args:
-            log_type (str): The type of log ('export_data_file' or 'export_original_file' or 'etc').
+            log_type (str): The type of log ('export_data_file' or 'export_original_file').
             target_id (int): The ID of the data file.
             data_file_info (dict): The JSON info of the data file.
             status (ExportStatus): The status of the data file.
@@ -89,16 +89,6 @@ class ExportRun(Run):
         """Log export origin data file."""
         self.log_file('export_original_file', target_id, data_file_info, status, error)
 
-    def export_log_etc_file(
-        self,
-        target_id: int,
-        data_file_info: dict,
-        status: ExportStatus = ExportStatus.STAND_BY,
-        error: str | None = None,
-    ):
-        """Log export etc file."""
-        self.log_file('etc', target_id, data_file_info, status, error)
-
 
 class ExportTargetHandler(ABC):
     """
@@ -210,7 +200,7 @@ class TaskExportTargetHandler(ExportTargetHandler):
         return value
 
     def get_results(self, client: Any, filters: dict):
-        filters['expand'] = 'data_unit'
+        filters['expand'] = ['data_unit', 'assignment', 'workshop']
         return client.list_tasks(params=filters, list_all=True)
 
     def get_export_item(self, results):
@@ -302,11 +292,6 @@ class ExportAction(Action):
             'failed': 0,
             'success': 0,
         },
-        'etc': {
-            'stand_by': 0,
-            'failed': 0,
-            'success': 0,
-        },
     }
 
     def get_filtered_results(self, filters, handler):
@@ -334,6 +319,7 @@ class ExportAction(Action):
                 first_result = next(peek_iter)  # Peek first value only
                 project_pk = first_result['project']
                 project_info = self.client.get_project(project_pk)
+                self.params['project_id'] = project_pk
                 self.params['configuration'] = project_info.get('configuration', {})
                 self.params['results'] = main_iter  # Keep original generator intact
             except (StopIteration, KeyError):

{synapse_sdk-1.0.0b6 → synapse_sdk-1.0.0b8/synapse_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0b6
+Version: 1.0.0b8
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT