synapse-sdk 1.0.0a23__py3-none-any.whl → 2025.12.3__py3-none-any.whl

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')

synapse_sdk/devtools/streamlit_app/ui/deployment_tab.py

@@ -0,0 +1,66 @@
+"""Deployment tab UI component."""
+
+import os
+
+import streamlit as st
+
+from synapse_sdk.devtools.config import get_backend_config
+
+from ..services.plugin_service import PluginService
+from ..utils.ui_components import (
+    render_action_button,
+    render_divider,
+    render_info_card,
+    render_key_value_pair,
+)
+
+
+class DeploymentTab:
+    """UI component for the Deployment tab."""
+
+    def __init__(self, plugin_service: PluginService):
+        self.plugin_service = plugin_service
+
+    def render(self):
+        """Render the Deployment tab."""
+        backend_config = get_backend_config()
+        if not backend_config:
+            st.error('Backend not configured')
+            return
+
+        # Display current configuration
+        col1, col2 = st.columns(2)
+        with col1:
+            st.text_input('Backend URL', value=backend_config['host'], disabled=True)
+        with col2:
+            st.text_input('Access Token', value='••••••••', disabled=True, type='password')
+
+        # Debug options
+        debug_mode = st.checkbox('Enable Debug Mode', value=True)
+        debug_modules = st.text_input('Debug Modules (comma-separated)', placeholder='module1,module2')
+
+        # Publish button
+        if render_action_button(
+            'Publish Plugin', key='publish_plugin', icon='🚀', type='primary', use_container_width=True
+        ):
+            with st.spinner('Publishing plugin...'):
+                # Set debug modules env var if provided
+                if debug_modules:
+                    os.environ['SYNAPSE_DEBUG_MODULES'] = debug_modules
+
+                result = self.plugin_service.publish_plugin(backend_config['host'], backend_config['token'], debug_mode)
+
+            if result['success']:
+                render_info_card('Published Successfully!', result['message'], type='success', icon='✅')
+
+                render_divider()
+
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    render_key_value_pair('Plugin Code', result['plugin_code'], monospace_value=True, inline=False)
+                with col2:
+                    render_key_value_pair('Version', result['version'], inline=False)
+                with col3:
+                    render_key_value_pair('Name', result['name'], inline=False)
+            else:
+                render_info_card('Publication Failed', result['error'], type='error', icon='❌')

synapse_sdk/devtools/streamlit_app/ui/http_tab.py

@@ -0,0 +1,125 @@
+"""HTTP Request tab UI component."""
+
+import json
+from typing import Optional
+
+import streamlit as st
+from streamlit_ace import st_ace
+
+from synapse_sdk.devtools.config import get_backend_config
+
+from ..services.plugin_service import PluginService
+from ..utils.json_viewer import render_json_compact
+from ..utils.ui_components import render_action_button, render_info_card, render_section_header
+
+
+class HttpTab:
+    """UI component for the HTTP Request tab."""
+
+    def __init__(self, plugin_service: PluginService, agent_id: Optional[int] = None):
+        self.plugin_service = plugin_service
+        self.agent_id = agent_id
+
+    def render(self):
+        """Render the HTTP Request tab."""
+        config = st.session_state.get('config', self.plugin_service.load_config())
+        if not config:
+            st.error('Please configure your plugin first')
+            return
+
+        # Get available actions
+        actions = list(config.get('actions', {}).keys())
+        if not actions:
+            st.warning('No actions configured in your plugin')
+            return
+
+        # Backend configuration check
+        backend_config = get_backend_config()
+        if not backend_config:
+            st.error('❌ Backend not configured')
+            return
+
+        # Action selection
+        selected_action = st.selectbox('Select Action', actions)
+
+        # Load parameters from test.http
+        test_http_params = self.plugin_service.parse_test_http()
+        default_params = test_http_params.get(selected_action, {})
+
+        # Parameters editor
+        render_section_header('Parameters', 'Parameters are automatically saved to test.http when request succeeds')
+        render_info_card(
+            'Editor Note',
+            'Ctrl+Enter keyboard shortcut is not available in the editor. Use the Execute button below.',
+            type='info',
+            icon='ℹ️',
+        )
+
+        params_str = st_ace(
+            value=json.dumps(default_params, indent=2),
+            language='json',
+            theme='monokai',
+            key=f'params_{selected_action}',
+            height=300,
+            auto_update=False,
+            font_size=14,
+        )
+
+        # Execute button
+        col1, col2 = st.columns([2, 1])
+        with col1:
+            execute_btn = render_action_button(
+                'Execute Request', key='execute_request', icon='▶', type='primary', use_container_width=True
+            )
+        with col2:
+            debug_mode = st.checkbox('Debug mode', value=True)
+
+        # Show endpoint reference
+        with st.expander('Endpoint Reference'):
+            plugin_code = config.get('code', 'plugin_code')
+            st.code(
+                f"""POST {backend_config['host']}/plugins/{plugin_code}/run/
+Content-Type: application/json
+Accept: application/json; indent=4
+SYNAPSE-Access-Token: Token ••••••••
+
+{{
+    "agent": {self.agent_id or 2},
+    "action": "{selected_action}",
+    "params": {params_str},
+    "debug": {str(debug_mode).lower()}
+}}""",
+                language='http',
+            )
+
+        # Execute request
+        if execute_btn:
+            try:
+                params = json.loads(params_str)
+
+                with st.spinner('Executing request...'):
+                    result = self.plugin_service.execute_plugin_action(
+                        selected_action, params, config.get('code'), self.agent_id, debug_mode
+                    )
+
+                # Display result
+                if result['success']:
+                    st.success(f'Success - Status: {result["status_code"]} - Time: {result["execution_time"]}ms')
+
+                    # Auto-save params on successful execution
+                    if self.plugin_service.update_test_http_params(selected_action, params):
+                        st.info('Parameters saved to test.http')
+                else:
+                    status_code = result.get('status_code', 'Unknown')
+                    exec_time = result.get('execution_time', 0)
+                    st.error(f'Failed - Status: {status_code} - Time: {exec_time}ms')
+
+                # Show response
+                if 'response_data' in result:
+                    st.markdown("<div style='margin-top: 20px;'></div>", unsafe_allow_html=True)
+                    render_json_compact(result['response_data'], 'Response')
+                elif 'error' in result:
+                    st.error(result['error'])
+
+            except json.JSONDecodeError as e:
+                st.error(f'Invalid JSON: {e}')