synapse-sdk 1.0.0a39__tar.gz → 1.0.0a41__tar.gz

{synapse_sdk-1.0.0a39/synapse_sdk.egg-info → synapse_sdk-1.0.0a41}/PKG-INFO

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

{synapse_sdk-1.0.0a39 → synapse_sdk-1.0.0a41}/synapse_sdk/plugins/categories/neural_net/actions/gradio.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from synapse_sdk.plugins.categories.base import Action
 from synapse_sdk.plugins.categories.decorators import register_action
 from synapse_sdk.plugins.enums import PluginCategory, RunMethod
+from synapse_sdk.utils.network import get_available_ports_host
 
 
 @register_action
@@ -21,8 +22,10 @@ class GradioAction(Action):
         return dir
 
     @property
-    def _requirements(self):
-        return self.config.get('requirements', ['gradio>=5'])
+    def requirements_file(self):
+        requirements_file = self.working_directory / 'requirements.txt'
+        if requirements_file.exists():
+            return requirements_file
 
     @property
     def tag(self):
@@ -31,7 +34,7 @@ class GradioAction(Action):
 
     @cached_property
     def deploy_port(self):
-        return self._get_avail_ports_host()
+        return get_available_ports_host()
 
     def deploy(self):
         self.run.log('deploy', 'Start deploying')
@@ -39,7 +42,7 @@ class GradioAction(Action):
         try:
             # Write Dockerfile and requirements.txt
             path_dockerfile = self.write_dockerfile_template()
-            self.write_requirements(path_dockerfile.parent / 'requirements.txt')
+            self.check_requirements()
 
             # Build docker image
             self.build_docker_image(path_dockerfile)
@@ -58,11 +61,15 @@ class GradioAction(Action):
         dockerfile_path = self.working_directory / 'Dockerfile'
 
         with open(dockerfile_path, 'w') as f:
-            f.write("""FROM python:3.10
+            f.write("""FROM python:3.12-slim
 WORKDIR /home/user/app
 
 RUN pip install --no-cache-dir pip -U && \\
     pip install --no-cache-dir uvicorn
+    
+RUN apt-get update && \\
+    apt-get install -y git nmap ffmpeg libsm6 libxext6 libgl1-mesa-glx && \\
+    rm -rf /var/lib/apt/lists/*
 
 RUN apt-get update && \\
     apt-get install -y curl && \\
@@ -81,48 +88,24 @@ CMD ["python", "app.py"]
 """)
         return dockerfile_path
 
-    def write_requirements(self, path):
-        with open(path, 'w') as f:
-            f.write('\n'.join(self._requirements))
+    def check_requirements(self):
+        default_packages = ['gradio', 'synapse-sdk', 'python-nmap']
+        if self.requirements_file is None:
+            with open(self.working_directory / 'requirements.txt', 'a') as f:
+                f.write('\n' + '\n'.join(default_packages))
+        else:
+            with open(self.requirements_file, 'a') as f:
+                f.write('\n' + '\n'.join(default_packages[1:]))
 
     def build_docker_image(self, path_dockerfile):
         self.run.log('deploy', 'Start building docker image')
         result = subprocess.run(
-            [
-                'docker',
-                'build',
-                '-t',
-                self.tag,
-                '-f',
-                str(path_dockerfile),
-                '.',
-            ],
+            ['docker', 'build', '-t', self.tag, '-f', str(path_dockerfile), '.'],
             cwd=self.working_directory,
             check=True,
         )
         print(result)
 
-    @staticmethod
-    def _get_avail_ports_host(start_port=8900, end_port=8999):
-        import nmap
-
-        nm = nmap.PortScanner()
-
-        scan_range = f'{start_port}-{end_port}'
-        nm.scan(hosts='host.docker.internal', arguments=f'-p {scan_range}')
-
-        try:
-            open_ports = nm['host.docker.internal']['tcp'].keys()
-            open_ports = [int(port) for port in open_ports]
-        except KeyError:
-            open_ports = []
-
-        for port in range(start_port, end_port + 1):
-            if port not in open_ports:
-                return port
-
-        raise IOError(f'No free ports available in range {start_port}-{end_port}')
-
     def run_docker_image(self):
         self.run.log('deploy', 'Start running docker image')
 
@@ -133,17 +116,30 @@ CMD ["python", "app.py"]
             subprocess.run(['docker', 'rm', self.tag], check=True)
 
         # Run docker image
-        self.run.log('deploy', 'Starting docker container')
+        command = [
+            'docker',
+            'run',
+            '-d',
+            '--name',
+            self.tag,
+            '-p',
+            f'{self.deploy_port}:7860',
+            '-p',
+            '8991-8999:8991-8999',
+            '--add-host',
+            'host.docker.internal:host-gateway',
+            '-e',
+            'GRADIO_SERVER_NAME=0.0.0.0',
+        ]
+
+        # extend synapse env vars
+        for key, value in self.envs.items():
+            command.extend(['-e', f'{key}={value}'])
+        command.append(self.tag)
+
+        self.run.log('deploy', f'Starting docker container with command: {" ".join(command)}')
+
         subprocess.run(
-            [
-                'docker',
-                'run',
-                '-d',
-                '--name',
-                self.tag,
-                '-p',
-                f'{self.deploy_port}:7860',
-                self.tag,
-            ],
+            command,
             check=True,
         )

{synapse_sdk-1.0.0a39 → synapse_sdk-1.0.0a41}/synapse_sdk/utils/file.py

@@ -4,7 +4,6 @@ import hashlib
 import json
 import mimetypes
 import operator
-import re
 import zipfile
 from functools import reduce
 from pathlib import Path

synapse_sdk-1.0.0a41/synapse_sdk/utils/http.py

@@ -0,0 +1,110 @@
+import logging
+import os
+import tempfile
+import threading
+import time
+from contextlib import contextmanager
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+
+from synapse_sdk.utils.network import get_available_ports_host
+
+
+class SingleFileHttpServer(SimpleHTTPRequestHandler):
+    """
+    Custom HTTP request handler that serves a single specified file
+    regardless of the request path.
+    """
+
+    def __init__(self, *args, file_path=None, content_type=None, **kwargs):
+        self.file_path = file_path
+        self.content_type = content_type
+        super().__init__(*args, **kwargs)
+
+    def do_GET(self):
+        """Handle GET requests by serving the single file."""
+        try:
+            # Always serve the specified file regardless of the path requested
+            self.send_response(200)
+            if self.content_type:
+                self.send_header('Content-type', self.content_type)
+            self.send_header('Content-Length', str(os.path.getsize(self.file_path)))
+            self.end_headers()
+
+            with open(self.file_path, 'rb') as file:
+                self.wfile.write(file.read())
+
+        except Exception as e:
+            self.send_error(500, str(e))
+
+
+@contextmanager
+def temp_file_server(image=None, file_path=None, format='JPEG', host='0.0.0.0', port=None, content_type=None):
+    """
+    Context manager that serves a file temporarily via HTTP.
+
+    Args:
+        image: A PIL Image object to serve (optional)
+        file_path: Path to an existing file to serve (optional - used if image not provided)
+        format: Image format when saving a PIL Image (default: "JPEG")
+        host: Host to serve on (default: "0.0.0.0")
+        port: Port to serve on (default: auto-selected free port)
+        content_type: Content type header (default: auto-detected based on format)
+
+    Returns:
+        URL where the file is being served
+
+    Usage:
+        with temp_file_serve(image=my_pillow_img) as url:
+            # use url to access the image
+            print(f"Image available at: {url}")
+    """
+    if image is None and file_path is None:
+        raise ValueError('Either image or file_path must be provided')
+
+    # Use a free port if none specified
+    if port is None:
+        port = get_available_ports_host(start_port=8991, end_port=8999)
+
+    temp_dir = None
+
+    try:
+        if image is not None:
+            temp_dir = tempfile.mkdtemp()
+            ext_map = {'JPEG': '.jpg', 'PNG': '.png', 'GIF': '.gif', 'WEBP': '.webp'}
+            content_type_map = {'JPEG': 'image/jpeg', 'PNG': 'image/png', 'GIF': 'image/gif', 'WEBP': 'image/webp'}
+
+            ext = ext_map.get(format, '.jpg')
+            if content_type is None:
+                content_type = content_type_map.get(format, 'image/jpeg')
+
+            temp_file_path = os.path.join(temp_dir, f'temp_image{ext}')
+            image.save(temp_file_path, format=format)
+            file_path = temp_file_path
+
+        def handler(*args, **kwargs):
+            return SingleFileHttpServer(*args, file_path=file_path, content_type=content_type, **kwargs)
+
+        server = HTTPServer((host, port), handler)
+
+        server_thread = threading.Thread(target=server.serve_forever)
+        server_thread.daemon = True
+        server_thread.start()
+
+        time.sleep(0.1)
+
+        url = f'http://localhost:{port}'
+
+        try:
+            yield url
+        finally:
+            server.shutdown()
+            server.server_close()
+
+    finally:
+        if temp_dir:
+            try:
+                if temp_file_path and os.path.exists(temp_file_path):
+                    os.unlink(temp_file_path)
+                os.rmdir(temp_dir)
+            except Exception as e:
+                logging.warning(f'Error cleaning up temporary files: {e}')

synapse_sdk-1.0.0a41/synapse_sdk/utils/network.py

@@ -0,0 +1,37 @@
+from urllib.parse import urlparse, urlunparse
+
+
+def clean_url(url, remove_query_params=True, remove_fragment=True):
+    parsed = urlparse(url)
+    query = '' if remove_query_params else parsed.query
+    fragment = '' if remove_fragment else parsed.fragment
+
+    return urlunparse((
+        parsed.scheme,
+        parsed.netloc,
+        parsed.path,
+        parsed.params,
+        query,
+        fragment,
+    ))
+
+
+def get_available_ports_host(start_port=8900, end_port=8990):
+    import nmap
+
+    nm = nmap.PortScanner()
+
+    scan_range = f'{start_port}-{end_port}'
+    nm.scan(hosts='host.docker.internal', arguments=f'-p {scan_range}')
+
+    try:
+        open_ports = nm['host.docker.internal']['tcp'].keys()
+        open_ports = [int(port) for port in open_ports]
+    except KeyError:
+        open_ports = []
+
+    for port in range(start_port, end_port + 1):
+        if port not in open_ports:
+            return port
+
+    raise IOError(f'No free ports available in range {start_port}-{end_port}')

{synapse_sdk-1.0.0a39 → synapse_sdk-1.0.0a41/synapse_sdk.egg-info}/PKG-INFO

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

{synapse_sdk-1.0.0a39 → synapse_sdk-1.0.0a41}/synapse_sdk.egg-info/SOURCES.txt

@@ -137,6 +137,7 @@ synapse_sdk/utils/__init__.py
 synapse_sdk/utils/dataset.py
 synapse_sdk/utils/debug.py
 synapse_sdk/utils/file.py
+synapse_sdk/utils/http.py
 synapse_sdk/utils/module_loading.py
 synapse_sdk/utils/network.py
 synapse_sdk/utils/string.py

synapse_sdk-1.0.0a39/synapse_sdk/utils/network.py

@@ -1,16 +0,0 @@
-from urllib.parse import urlparse, urlunparse
-
-
-def clean_url(url, remove_query_params=True, remove_fragment=True):
-    parsed = urlparse(url)
-    query = '' if remove_query_params else parsed.query
-    fragment = '' if remove_fragment else parsed.fragment
-
-    return urlunparse((
-        parsed.scheme,
-        parsed.netloc,
-        parsed.path,
-        parsed.params,
-        query,
-        fragment,
-    ))