synapse-sdk 1.0.0a38__tar.gz → 1.0.0a40__tar.gz

{synapse_sdk-1.0.0a38/synapse_sdk.egg-info → synapse_sdk-1.0.0a40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0a38
+Version: 1.0.0a40
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: universal-pathlib
 Requires-Dist: fsspec[gcs,s3,sftp]
 Provides-Extra: all
 Requires-Dist: ray[all]; extra == "all"
+Requires-Dist: python-nmap; extra == "all"
 Dynamic: license-file
 
 This is the SDK to develop synapse plugins

{synapse_sdk-1.0.0a38 → synapse_sdk-1.0.0a40}/pyproject.toml

@@ -29,7 +29,8 @@ dynamic = ["version"]
 
 [project.optional-dependencies]
 all = [
-    "ray[all]"
+    "ray[all]",
+    "python-nmap"
 ]
 
 [project.scripts]

synapse_sdk-1.0.0a40/synapse_sdk/plugins/categories/neural_net/actions/deployment.py

@@ -0,0 +1,58 @@
+from synapse_sdk.clients.exceptions import ClientError
+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
+
+
+@register_action
+class DeploymentAction(Action):
+    name = 'deployment'
+    category = PluginCategory.NEURAL_NET
+    method = RunMethod.JOB
+
+    def get_actor_options(self):
+        options = {'runtime_env': self.get_runtime_env()}
+        for option in ['num_cpus', 'num_gpus']:
+            option_value = self.params.get(option)
+            if option_value:
+                options[option] = option_value
+        return options
+
+    def start(self):
+        from ray import serve
+
+        from synapse_sdk.plugins.categories.neural_net.base.inference import app
+
+        self.ray_init()
+
+        ray_actor_options = self.get_actor_options()
+
+        deployment = serve.deployment(ray_actor_options=ray_actor_options)(serve.ingress(app)(self.entrypoint)).bind(
+            self.envs['SYNAPSE_PLUGIN_RUN_HOST']
+        )
+
+        serve.delete(self.plugin_release.code)
+
+        # TODO add run object
+        serve.run(
+            deployment,
+            name=self.plugin_release.code,
+            route_prefix=f'/{self.plugin_release.checksum}',
+        )
+
+        # 백엔드에 ServeApplication 추가
+        serve_application = self.create_serve_application()
+        return {'serve_application': serve_application['id'] if serve_application else None}
+
+    def create_serve_application(self):
+        if self.job_id:
+            try:
+                serve_application = self.ray_client.get_serve_application(self.plugin_release.code)
+                return self.client.create_serve_application({
+                    'job': self.job_id,
+                    'status': serve_application['status'],
+                    'data': serve_application,
+                })
+            except ClientError:
+                pass
+        return None

synapse_sdk-1.0.0a40/synapse_sdk/plugins/categories/neural_net/actions/gradio.py

@@ -0,0 +1,131 @@
+import contextlib
+import subprocess
+from functools import cached_property
+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
+class GradioAction(Action):
+    name = 'gradio'
+    category = PluginCategory.NEURAL_NET
+    method = RunMethod.JOB
+
+    @property
+    def working_directory(self):
+        dir = Path.cwd() / self.config['directory'].replace('.', '/')
+        assert dir.is_dir(), f'Working directory {dir} does not exist.'
+        return dir
+
+    @property
+    def _requirements(self):
+        return self.config.get('requirements', ['gradio>=5'])
+
+    @property
+    def tag(self):
+        _tag = f'{self.plugin_release.code}-{self.plugin_release.checksum}'
+        return _tag.replace('@', '-')
+
+    @cached_property
+    def deploy_port(self):
+        return get_available_ports_host()
+
+    def deploy(self):
+        self.run.log('deploy', 'Start deploying')
+
+        try:
+            # Write Dockerfile and requirements.txt
+            path_dockerfile = self.write_dockerfile_template()
+            self.write_requirements(path_dockerfile.parent / 'requirements.txt')
+
+            # Build docker image
+            self.build_docker_image(path_dockerfile)
+
+            # Run docker image
+            self.run_docker_image()
+        except Exception as e:
+            self.run.log('deploy', f'Error: {e}')
+            raise e
+
+    def start(self):
+        self.deploy()
+        return {'endpoint': f'http://localhost:{self.deploy_port}'}
+
+    def write_dockerfile_template(self):
+        dockerfile_path = self.working_directory / 'Dockerfile'
+
+        with open(dockerfile_path, 'w') as f:
+            f.write("""FROM python:3.10
+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 curl && \\
+    curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \\
+    apt-get install -y nodejs && \\
+    rm -rf /var/lib/apt/lists/* && \\
+    apt-get clean
+
+COPY . /home/user/app
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 7860
+
+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 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),
+                '.',
+            ],
+            cwd=self.working_directory,
+            check=True,
+        )
+        print(result)
+
+    def run_docker_image(self):
+        self.run.log('deploy', 'Start running docker image')
+
+        # Check for existing container
+        self.run.log('deploy', 'Check for existing container')
+        with contextlib.suppress(subprocess.CalledProcessError):
+            subprocess.run(['docker', 'stop', self.tag], check=True)
+            subprocess.run(['docker', 'rm', self.tag], check=True)
+
+        # Run docker image
+        self.run.log('deploy', 'Starting docker container')
+        subprocess.run(
+            [
+                'docker',
+                'run',
+                '-d',
+                '--name',
+                self.tag,
+                '-p',
+                f'{self.deploy_port}:7860',
+                '-p',
+                '8991-8999:8991-8999',
+                self.tag,
+            ],
+            check=True,
+        )

{synapse_sdk-1.0.0a38 → synapse_sdk-1.0.0a40}/synapse_sdk/utils/file.py

@@ -197,6 +197,10 @@ def convert_file_to_base64(file_path):
     Returns:
         str: Base64 encoded string of the file contents
     """
+    # FIXME base64 is sent sometimes.
+    if file_path.startswith('data:'):
+        return file_path
+
     # Convert string path to Path object
     path = Path(file_path)
 

synapse_sdk-1.0.0a40/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='localhost', 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: "localhost")
+        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://{host}:{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.0a40/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.0a38 → synapse_sdk-1.0.0a40/synapse_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0a38
+Version: 1.0.0a40
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: universal-pathlib
 Requires-Dist: fsspec[gcs,s3,sftp]
 Provides-Extra: all
 Requires-Dist: ray[all]; extra == "all"
+Requires-Dist: python-nmap; extra == "all"
 Dynamic: license-file
 
 This is the SDK to develop synapse plugins

{synapse_sdk-1.0.0a38 → synapse_sdk-1.0.0a40}/synapse_sdk.egg-info/SOURCES.txt

@@ -85,6 +85,7 @@ synapse_sdk/plugins/categories/export/templates/plugin/export.py
 synapse_sdk/plugins/categories/neural_net/__init__.py
 synapse_sdk/plugins/categories/neural_net/actions/__init__.py
 synapse_sdk/plugins/categories/neural_net/actions/deployment.py
+synapse_sdk/plugins/categories/neural_net/actions/gradio.py
 synapse_sdk/plugins/categories/neural_net/actions/inference.py
 synapse_sdk/plugins/categories/neural_net/actions/test.py
 synapse_sdk/plugins/categories/neural_net/actions/train.py
@@ -136,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.0a38 → synapse_sdk-1.0.0a40}/synapse_sdk.egg-info/requires.txt

@@ -12,3 +12,4 @@ fsspec[gcs,s3,sftp]
 
 [all]
 ray[all]
+python-nmap

synapse_sdk-1.0.0a38/synapse_sdk/plugins/categories/neural_net/actions/deployment.py

@@ -1,107 +0,0 @@
-from packaging import version
-
-from synapse_sdk.clients.exceptions import ClientError
-from synapse_sdk.i18n import gettext as _
-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
-
-
-@register_action
-class DeploymentAction(Action):
-    name = 'deployment'
-    category = PluginCategory.NEURAL_NET
-    method = RunMethod.JOB
-
-    def get_actor_options(self):
-        options = {'runtime_env': self.get_runtime_env()}
-        for option in ['num_cpus', 'num_gpus']:
-            option_value = self.params.get(option)
-            if option_value:
-                options[option] = option_value
-        return options
-
-    def start(self):
-        from ray import serve
-
-        from synapse_sdk.plugins.categories.neural_net.base.inference import app
-
-        self.ray_init()
-
-        ray_actor_options = self.get_actor_options()
-
-        if self.is_gradio_deployment:
-            from ray.serve.gradio_integrations import GradioServer
-
-            self.assert_gradio_version()
-
-            # GradioIngress differs from serve.ingress(app), thus the difference in self.entrypoint callable
-            try:
-                entrypoint = self.entrypoint().app
-            except (TypeError, ImportError):
-                raise ClientError(
-                    400,
-                    _(
-                        'Gradio app is not callable.'
-                        'Please ensure that your Deployment class defines a callable `app` function'
-                    ),
-                )
-
-            deployment = GradioServer.options(ray_actor_options=ray_actor_options).bind(entrypoint)
-        else:
-            deployment = serve.deployment(ray_actor_options=ray_actor_options)(
-                serve.ingress(app)(self.entrypoint)
-            ).bind(self.envs['SYNAPSE_PLUGIN_RUN_HOST'])
-
-        serve.delete(self.plugin_release.code)
-
-        # TODO add run object
-        serve.run(
-            deployment,
-            name=self.plugin_release.code,
-            route_prefix=f'/{self.plugin_release.checksum}',
-        )
-
-        # 백엔드에 ServeApplication 추가
-        serve_application = self.create_serve_application()
-        return {'serve_application': serve_application['id'] if serve_application else None}
-
-    def create_serve_application(self):
-        if self.job_id:
-            try:
-                serve_application = self.ray_client.get_serve_application(self.plugin_release.code)
-                return self.client.create_serve_application({
-                    'job': self.job_id,
-                    'status': serve_application['status'],
-                    'data': serve_application,
-                })
-            except ClientError:
-                pass
-        return None
-
-    @property
-    def is_gradio_deployment(self):
-        return self.config.get('gradio_app', False)
-
-    def assert_gradio_version(self):
-        """Assert gradio version is not greater than 3.50.2.
-        Ray Serve cannot pickle gradio endpoints, thus gradio version greater than 3.50.2 is not supported (SSE Issues)
-        """
-        GRADIO_VERSION_MAX_ALLOWED = '3.50.2'
-
-        gradio_installed = False
-        gradio_version = None
-        for req in self.requirements:
-            if req.startswith('gradio=='):
-                gradio_installed = True
-                gradio_version = req.split('==')[1]
-                break
-
-        assert gradio_installed, _(
-            'Gradio is not installed or version is not specified. Please install gradio==3.50.2 to use this feature.'
-        )
-
-        if version.parse(gradio_version) > version.parse(GRADIO_VERSION_MAX_ALLOWED):
-            raise AssertionError(
-                f'Gradio version {gradio_version} is greater than maximum allowed version {GRADIO_VERSION_MAX_ALLOWED}'
-            )

synapse_sdk-1.0.0a38/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,
-    ))