synapse-sdk 1.0.0a13__py3-none-any.whl → 2025.11.7__py3-none-any.whl

synapse_sdk/devtools/streamlit_app/services/job_service.py

@@ -0,0 +1,233 @@
+"""Job service for managing job operations."""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from synapse_sdk.clients.backend import BackendClient
+from synapse_sdk.clients.exceptions import ClientError
+
+
+class JobService:
+    """Service for job-related operations."""
+
+    def __init__(self, backend_client: Optional[BackendClient] = None):
+        self.backend_client = backend_client
+
+    def list_jobs(self, agent_id: Optional[int] = None, agent_info: Optional[Dict] = None) -> List[Dict]:
+        """List jobs from the backend."""
+        if not self.backend_client:
+            return []
+
+        try:
+            params = {}
+            if agent_id:
+                params['agent'] = agent_id
+
+            jobs_response = self.backend_client.list_jobs(params=params)
+
+            # Handle paginated response - extract results
+            if jobs_response is None:
+                return []
+            elif isinstance(jobs_response, dict) and 'results' in jobs_response:
+                jobs = jobs_response['results']
+            else:
+                jobs = jobs_response if isinstance(jobs_response, list) else []
+
+            # Remove None jobs and sort by created time (most recent first)
+            valid_jobs = [job for job in jobs if job is not None]
+            valid_jobs.sort(key=lambda job: job.get('created', ''), reverse=True)
+
+            # Try to enrich jobs with plugin names
+            enriched_jobs = []
+            for job in valid_jobs:
+                enriched_job = job.copy()
+
+                # Try to get plugin info
+                if 'plugin_release' in job:
+                    try:
+                        # Try to fetch plugin release details
+                        plugin_release_response = self.backend_client.get(f'/plugin_releases/{job["plugin_release"]}/')
+                        if plugin_release_response and isinstance(plugin_release_response, dict):
+                            # Get version from plugin release
+                            enriched_job['plugin_version'] = plugin_release_response.get('version')
+
+                            # Try to get plugin details from the plugin ID
+                            plugin_id = plugin_release_response.get('plugin')
+                            if plugin_id:
+                                try:
+                                    plugin_response = self.backend_client.get(f'/plugins/{plugin_id}/')
+                                    if plugin_response and isinstance(plugin_response, dict):
+                                        enriched_job['plugin_name'] = plugin_response.get('name')
+                                        enriched_job['plugin_code'] = plugin_response.get('code')
+                                except Exception:
+                                    # Fallback to config if plugin fetch fails
+                                    config = plugin_release_response.get('config', {})
+                                    enriched_job['plugin_name'] = config.get('name') or config.get('code')
+                                    enriched_job['plugin_code'] = config.get('code')
+                            else:
+                                # Fallback to config if no plugin ID
+                                config = plugin_release_response.get('config', {})
+                                enriched_job['plugin_name'] = config.get('name') or config.get('code')
+                                enriched_job['plugin_code'] = config.get('code')
+                    except Exception:
+                        pass
+
+                # Try to get agent info
+                if 'agent' in job:
+                    # First check if we have local agent info
+                    if agent_info and job.get('agent') == agent_id:
+                        enriched_job['agent_name'] = agent_info.get('name')
+                        enriched_job['agent_url'] = agent_info.get('url')
+                    else:
+                        # Try to fetch agent details from API
+                        try:
+                            agent_response = self.backend_client.get(f'/agents/{job["agent"]}/')
+                            if agent_response and isinstance(agent_response, dict):
+                                enriched_job['agent_name'] = agent_response.get('name')
+                                enriched_job['agent_url'] = agent_response.get('url')
+                        except Exception:
+                            pass
+
+                enriched_jobs.append(enriched_job)
+
+            return enriched_jobs
+        except ClientError:
+            raise
+        except Exception as e:
+            raise Exception(f'Failed to list jobs: {e}')
+
+    def get_job_logs(self, job_id: str):
+        """Get all logs for a job at once."""
+        if not self.backend_client:
+            raise Exception('Backend client not configured')
+
+        try:
+            # Get logs from console_logs endpoint (returns list of strings)
+            logs_response = self.backend_client.list_job_console_logs(job_id)
+
+            # API returns a list of log strings
+            if isinstance(logs_response, list):
+                if not logs_response:
+                    # Empty list means no logs yet
+                    yield 'No logs available for this job yet.\n'
+                else:
+                    for log_entry in logs_response:
+                        # Each entry is already a formatted string with timestamp
+                        yield str(log_entry) + '\n' if not str(log_entry).endswith('\n') else str(log_entry)
+            elif logs_response:
+                # Fallback for unexpected format
+                yield str(logs_response) + '\n'
+            else:
+                yield 'No logs available for this job yet.\n'
+
+        except Exception as e:
+            from synapse_sdk.clients.exceptions import ClientError
+
+            # Check if it's a ClientError with specific status
+            if isinstance(e, ClientError):
+                if e.status == 404:
+                    yield 'Job not found or logs not available.\n'
+                elif e.status == 401:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    # Check for Korean error message in the reason
+                    error_str = str(e.reason) if hasattr(e, 'reason') else str(e)
+                    if '찾을 수 없습니다' in error_str:
+                        yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                    else:
+                        yield f'Failed to fetch logs: {error_str}\n'
+            else:
+                error_str = str(e)
+                if '찾을 수 없습니다' in error_str or '404' in error_str or 'Not found' in error_str:
+                    yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                elif '401' in error_str or 'Unauthorized' in error_str:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    yield f'Failed to fetch logs: {error_str}\n'
+
+    def stream_job_logs(self, job_id: str):
+        """Stream logs for a job (simulated streaming since tail endpoint doesn't exist)."""
+        if not self.backend_client:
+            raise Exception('Backend client not configured')
+
+        # Since tail_console_logs endpoint returns 404, we'll simulate streaming
+        # by fetching all logs and yielding them one by one
+        try:
+            from synapse_sdk.clients.exceptions import ClientError
+
+            # Get logs from console_logs endpoint (returns list of strings)
+            logs_response = self.backend_client.list_job_console_logs(job_id)
+
+            # API returns a list of log strings
+            if isinstance(logs_response, list):
+                if not logs_response:
+                    # Empty list means no logs yet
+                    yield 'No logs available for this job yet.\n'
+                else:
+                    # Yield logs one by one to simulate streaming
+                    for log_entry in logs_response:
+                        # Each entry is already a formatted string with timestamp
+                        yield str(log_entry) + '\n' if not str(log_entry).endswith('\n') else str(log_entry)
+            elif logs_response:
+                # Fallback for unexpected format
+                yield str(logs_response) + '\n'
+            else:
+                yield 'No logs available for this job yet.\n'
+
+        except Exception as e:
+            # Check if it's a ClientError with specific status
+            if isinstance(e, ClientError):
+                if e.status == 404:
+                    yield 'Job not found or logs not available.\n'
+                elif e.status == 401:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    # Check for Korean error message in the reason
+                    error_str = str(e.reason) if hasattr(e, 'reason') else str(e)
+                    if '찾을 수 없습니다' in error_str:
+                        yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                    else:
+                        yield f'Failed to stream logs: {error_str}\n'
+            else:
+                error_str = str(e)
+                if '찾을 수 없습니다' in error_str or '404' in error_str or 'Not found' in error_str:
+                    yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                elif '401' in error_str or 'Unauthorized' in error_str:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    yield f'Failed to stream logs: {error_str}\n'
+
+    @staticmethod
+    def format_duration(created: str, completed: Optional[str] = None) -> str:
+        """Format duration between created and completed timestamps."""
+        if not created:
+            return '-'
+
+        try:
+            created_dt = datetime.fromisoformat(created.replace('+09:00', '+09:00'))
+            if completed:
+                completed_dt = datetime.fromisoformat(completed.replace('+09:00', '+09:00'))
+                duration = completed_dt - created_dt
+                total_seconds = int(duration.total_seconds())
+                if total_seconds < 60:
+                    return f'{total_seconds}s'
+                else:
+                    minutes = total_seconds // 60
+                    seconds = total_seconds % 60
+                    return f'{minutes}m {seconds}s'
+            else:
+                return '...'
+        except Exception:
+            return '-'
+
+    @staticmethod
+    def format_timestamp(timestamp: str) -> str:
+        """Format timestamp for display."""
+        if not timestamp:
+            return '-'
+
+        try:
+            dt = datetime.fromisoformat(timestamp.replace('+09:00', '+09:00'))
+            return dt.strftime('%m/%d %H:%M')
+        except Exception:
+            return timestamp[:16] if len(timestamp) > 16 else timestamp

synapse_sdk/devtools/streamlit_app/services/plugin_service.py

@@ -0,0 +1,236 @@
+"""Plugin service for managing plugin operations."""
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+import yaml
+
+from synapse_sdk.cli.plugin.publish import _publish
+from synapse_sdk.clients.backend import BackendClient
+
+
+class PluginService:
+    """Service for plugin-related operations."""
+
+    def __init__(self, plugin_directory: Path, backend_client: Optional[BackendClient] = None):
+        self.plugin_directory = plugin_directory
+        self.config_path = plugin_directory / 'config.yaml'
+        self.test_http_path = plugin_directory / 'test.http'
+        self.backend_client = backend_client
+
+    def load_config(self) -> Dict:
+        """Load plugin configuration from config.yaml."""
+        if not self.config_path.exists():
+            return {}
+
+        try:
+            with open(self.config_path, 'r') as f:
+                return yaml.safe_load(f)
+        except Exception:
+            return {}
+
+    def save_config(self, config: Dict) -> bool:
+        """Save plugin configuration to config.yaml."""
+        try:
+            # Backup existing config
+            if self.config_path.exists():
+                backup_path = self.config_path.with_suffix('.yaml.bak')
+                self.config_path.rename(backup_path)
+
+            # Write new config
+            with open(self.config_path, 'w') as f:
+                yaml.dump(config, f, default_flow_style=False, allow_unicode=True, indent=2)
+
+            return True
+        except Exception:
+            # Restore backup if write failed
+            backup_path = self.config_path.with_suffix('.yaml.bak')
+            if backup_path.exists():
+                backup_path.rename(self.config_path)
+            return False
+
+    def parse_test_http(self) -> Dict[str, Dict]:
+        """Parse test.http file and extract action parameters."""
+        if not self.test_http_path.exists():
+            return {}
+
+        requests = {}
+        current_request_name = None
+        current_body_lines = []
+        in_body = False
+
+        try:
+            with open(self.test_http_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith('###'):
+                        # Process previous request
+                        if current_request_name and current_body_lines:
+                            try:
+                                full_request = json.loads(''.join(current_body_lines))
+                                if 'params' in full_request:
+                                    requests[current_request_name] = full_request['params']
+                            except json.JSONDecodeError:
+                                pass
+
+                        # Start new request
+                        current_request_name = line.replace('###', '').strip()
+                        current_body_lines = []
+                        in_body = False
+                    elif current_request_name and line.startswith('{'):
+                        in_body = True
+                        current_body_lines.append(line)
+                    elif in_body and current_request_name:
+                        current_body_lines.append(line)
+
+                # Process last request
+                if current_request_name and current_body_lines:
+                    try:
+                        full_request = json.loads(''.join(current_body_lines))
+                        if 'params' in full_request:
+                            requests[current_request_name] = full_request['params']
+                    except json.JSONDecodeError:
+                        pass
+
+            return requests
+        except Exception:
+            return {}
+
+    def update_test_http_params(self, action: str, new_params: Dict) -> bool:
+        """Update parameters for a specific action in test.http."""
+        if not self.test_http_path.exists():
+            return False
+
+        try:
+            with open(self.test_http_path, 'r') as f:
+                lines = f.readlines()
+
+            current_action = None
+            in_json = False
+            json_start_line = -1
+            json_lines = []
+            updated = False
+
+            for i, line in enumerate(lines):
+                if line.strip().startswith('###'):
+                    current_action = line.replace('###', '').strip()
+                    in_json = False
+                    json_lines = []
+                elif current_action and line.strip().startswith('{'):
+                    in_json = True
+                    json_start_line = i
+                    json_lines = [line]
+                elif in_json:
+                    json_lines.append(line)
+                    if line.strip() == '}':
+                        if current_action == action:
+                            try:
+                                full_json = json.loads(''.join(json_lines))
+                                full_json['params'] = new_params
+                                new_json = json.dumps(full_json, indent=2)
+                                lines[json_start_line : i + 1] = [new_json + '\n']
+                                updated = True
+                                break
+                            except json.JSONDecodeError:
+                                pass
+                        in_json = False
+                        json_lines = []
+
+            if updated:
+                with open(self.test_http_path, 'w') as f:
+                    f.writelines(lines)
+                return True
+
+            return False
+        except Exception:
+            return False
+
+    def execute_plugin_action(
+        self, action: str, params: Dict, plugin_code: str, agent_id: Optional[int] = None, debug: bool = True
+    ) -> Dict:
+        """Execute a plugin action via HTTP request."""
+        if not self.backend_client:
+            return {'success': False, 'error': 'Backend client not configured'}
+
+        if not plugin_code:
+            return {'success': False, 'error': 'Plugin code not found in configuration'}
+
+        plugin_url = f'{self.backend_client.base_url}/plugins/{plugin_code}/run/'
+
+        headers = {
+            'Accept': 'application/json; indent=4',
+            'Content-Type': 'application/json',
+        }
+
+        # Get auth headers from backend client
+        auth_headers = self.backend_client._get_headers()
+        headers.update(auth_headers)
+
+        payload = {
+            'agent': agent_id or 2,
+            'action': action,
+            'params': params,
+            'debug': debug,
+        }
+
+        start_time = time.time()
+
+        try:
+            import requests
+
+            response = requests.post(plugin_url, json=payload, headers=headers, timeout=30)
+            execution_time = int((time.time() - start_time) * 1000)
+
+            try:
+                response_data = response.json()
+            except Exception:
+                response_data = response.text
+
+            return {
+                'success': response.status_code < 400,
+                'status_code': response.status_code,
+                'response_data': response_data,
+                'execution_time': execution_time,
+                'url': plugin_url,
+                'method': 'POST',
+                'headers': headers,
+                'payload': payload,
+            }
+        except Exception as e:
+            execution_time = int((time.time() - start_time) * 1000)
+            return {
+                'success': False,
+                'status_code': 500,
+                'error': str(e),
+                'execution_time': execution_time,
+                'url': plugin_url,
+            }
+
+    def publish_plugin(self, host: str, access_token: str, debug: bool = True) -> Dict:
+        """Publish plugin to Synapse platform."""
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(str(self.plugin_directory))
+
+            debug_modules = os.getenv('SYNAPSE_DEBUG_MODULES', '')
+            plugin_release = _publish(host, access_token, debug, debug_modules)
+
+            return {
+                'success': True,
+                'message': (
+                    f'Successfully published "{plugin_release.name}" ({plugin_release.code}) to synapse backend!'
+                ),
+                'plugin_code': plugin_release.code,
+                'version': plugin_release.version,
+                'name': plugin_release.name,
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e),
+            }
+        finally:
+            os.chdir(original_cwd)

synapse_sdk/devtools/streamlit_app/services/serve_service.py

@@ -0,0 +1,95 @@
+"""Serve service for managing serve deployments."""
+
+from typing import Dict, List, Optional
+
+from synapse_sdk.clients.backend import BackendClient
+from synapse_sdk.clients.exceptions import ClientError
+
+
+class ServeService:
+    """Service for serve deployment operations."""
+
+    def __init__(self, backend_client: Optional[BackendClient] = None):
+        self.backend_client = backend_client
+
+    def list_serve_applications(self, agent_id: Optional[int] = None, agent_info: Optional[Dict] = None) -> List[Dict]:
+        """List serve applications from the backend."""
+        if not self.backend_client:
+            return []
+
+        try:
+            params = {}
+            if agent_id:
+                params['agent'] = agent_id
+
+            apps_response = self.backend_client.list_serve_applications(params=params)
+
+            # Handle paginated response - extract results
+            if apps_response is None:
+                return []
+            elif isinstance(apps_response, dict) and 'results' in apps_response:
+                applications = apps_response['results']
+            else:
+                applications = apps_response if isinstance(apps_response, list) else []
+
+            # Remove None applications
+            valid_apps = [app for app in applications if app is not None]
+
+            # Try to enrich applications with plugin and agent names
+            enriched_apps = []
+            for app in valid_apps:
+                enriched_app = app.copy()
+
+                # Try to get plugin info
+                if 'plugin_release' in app:
+                    try:
+                        # Try to fetch plugin release details
+                        plugin_release_response = self.backend_client.get(f'/plugin_releases/{app["plugin_release"]}/')
+                        if plugin_release_response and isinstance(plugin_release_response, dict):
+                            # Get version from plugin release
+                            enriched_app['plugin_version'] = plugin_release_response.get('version')
+
+                            # Try to get plugin details from the plugin ID
+                            plugin_id = plugin_release_response.get('plugin')
+                            if plugin_id:
+                                try:
+                                    plugin_response = self.backend_client.get(f'/plugins/{plugin_id}/')
+                                    if plugin_response and isinstance(plugin_response, dict):
+                                        enriched_app['plugin_name'] = plugin_response.get('name')
+                                        enriched_app['plugin_code'] = plugin_response.get('code')
+                                except Exception:
+                                    # Fallback to config if plugin fetch fails
+                                    config = plugin_release_response.get('config', {})
+                                    enriched_app['plugin_name'] = config.get('name') or config.get('code')
+                                    enriched_app['plugin_code'] = config.get('code')
+                            else:
+                                # Fallback to config if no plugin ID
+                                config = plugin_release_response.get('config', {})
+                                enriched_app['plugin_name'] = config.get('name') or config.get('code')
+                                enriched_app['plugin_code'] = config.get('code')
+                    except Exception:
+                        pass
+
+                # Try to get agent info
+                if 'agent' in app:
+                    # First check if we have local agent info
+                    if agent_info and app.get('agent') == agent_id:
+                        enriched_app['agent_name'] = agent_info.get('name')
+                        enriched_app['agent_url'] = agent_info.get('url')
+                    else:
+                        # Try to fetch agent details from API
+                        try:
+                            agent_response = self.backend_client.get(f'/agents/{app["agent"]}/')
+                            if agent_response and isinstance(agent_response, dict):
+                                enriched_app['agent_name'] = agent_response.get('name')
+                                enriched_app['agent_url'] = agent_response.get('url')
+                        except Exception:
+                            pass
+
+                enriched_apps.append(enriched_app)
+
+            return enriched_apps
+        except ClientError:
+            raise
+        except Exception as e:
+            raise Exception(f'Failed to list serve applications: {e}')

synapse_sdk/devtools/streamlit_app/ui/__init__.py

@@ -0,0 +1,15 @@
+"""UI components for the Streamlit app."""
+
+from .config_tab import ConfigTab
+from .deployment_tab import DeploymentTab
+from .http_tab import HttpTab
+from .jobs_tab import JobsTab
+from .serve_tab import ServeTab
+
+__all__ = [
+    'ConfigTab',
+    'DeploymentTab',
+    'HttpTab',
+    'JobsTab',
+    'ServeTab',
+]

synapse_sdk/devtools/streamlit_app/ui/config_tab.py

@@ -0,0 +1,76 @@
+"""Configuration tab UI component."""
+
+import streamlit as st
+
+from ..services.plugin_service import PluginService
+from ..utils.ui_components import render_info_card
+
+
+class ConfigTab:
+    """UI component for the Configuration tab."""
+
+    def __init__(self, plugin_service: PluginService):
+        self.plugin_service = plugin_service
+
+    def render(self):
+        """Render the Configuration tab."""
+        config = st.session_state.get('config', self.plugin_service.load_config())
+
+        if not config:
+            render_info_card(
+                'No Configuration',
+                'No plugin configuration file found. Please create a config.yaml file.',
+                type='error',
+            )
+            return
+
+        # Display file path
+        render_info_card('Configuration File', str(self.plugin_service.config_path), type='neutral', icon='📁')
+
+        # Configuration form
+        with st.form('config_form'):
+            col1, col2 = st.columns(2)
+
+            with col1:
+                config['name'] = st.text_input('Plugin Name', value=config.get('name', ''))
+                config['code'] = st.text_input('Code', value=config.get('code', ''))
+                config['version'] = st.text_input('Version', value=config.get('version', ''))
+
+                categories = [
+                    'neural_net',
+                    'export',
+                    'upload',
+                    'smart_tool',
+                    'post_annotation',
+                    'pre_annotation',
+                    'data_validation',
+                ]
+                current_category = config.get('category', '')
+                category_index = categories.index(current_category) if current_category in categories else 0
+                config['category'] = st.selectbox('Category', categories, index=category_index)
+
+            with col2:
+                data_types = ['image', 'text', 'video', 'pcd', 'audio']
+                current_data_type = config.get('data_type', '')
+                data_type_index = data_types.index(current_data_type) if current_data_type in data_types else 0
+                config['data_type'] = st.selectbox('Data Type', data_types, index=data_type_index)
+
+                package_managers = ['pip', 'uv']
+                current_pm = config.get('package_manager', '')
+                pm_index = package_managers.index(current_pm) if current_pm in package_managers else 0
+                config['package_manager'] = st.selectbox('Package Manager', package_managers, index=pm_index)
+
+            config['description'] = st.text_area('Description', value=config.get('description', ''), height=100)
+
+            config_tasks = config.get('tasks', [])
+            tasks_str = ', '.join(config_tasks) if isinstance(config_tasks, list) else config.get('tasks', '')
+            tasks_input = st.text_input('Task Types (comma-separated)', value=tasks_str)
+            config['tasks'] = [t.strip() for t in tasks_input.split(',') if t.strip()]
+
+            if st.form_submit_button('Save Configuration', type='primary'):
+                st.session_state['config'] = config
+                if self.plugin_service.save_config(config):
+                    st.success('✅ Configuration saved successfully!')
+                    st.rerun()
+                else:
+                    st.error('Failed to save configuration')