synapse-sdk 0.0.0__py3-none-any.whl

synapse/client/__init__.py

@@ -0,0 +1,89 @@
+import os
+import json
+from pathlib import Path
+
+import requests
+
+from .exceptions import ClientError
+from .mixins.annotation import AnnotationClientMixin
+from .mixins.dataset import DatasetClientMixin
+from .mixins.integration import IntegrationClientMixin
+from .mixins.ml import MLClientMixin
+from ..utils.file import files_url_to_path_from_objs
+
+
+class Client(AnnotationClientMixin, DatasetClientMixin, IntegrationClientMixin, MLClientMixin):
+    base_url = None
+    token = None
+    workspace_code = None
+
+    def __init__(self, base_url, token, workspace_code=None):
+        self.base_url = base_url
+        self.token = token
+        if workspace_code:
+            self.workspace_code = workspace_code
+        requests_session = requests.Session()
+        self.requests_session = requests_session
+
+    def _get_url(self, path):
+        if not path.startswith(self.base_url):
+            return os.path.join(self.base_url, path)
+        return path
+
+    def _get_headers(self):
+        headers = {'Authorization': f'Token {self.token}'}
+        if self.workspace_code:
+            headers['DATAMAKER-Workspace'] = f'Token {self.workspace_code}'
+        return headers
+
+    def _request(self, method, path, **kwargs):
+        url = self._get_url(path)
+        headers = self._get_headers()
+
+        if method in ['post', 'put', 'patch']:
+            if kwargs.get('files') is not None:
+                for name, file in kwargs['files'].items():
+                    kwargs['files'][name] = Path(str(file)).open(mode='rb')
+            else:
+                headers['Content-Type'] = 'application/json'
+                if 'data' in kwargs:
+                    kwargs['data'] = json.dumps(kwargs['data'])
+
+        try:
+            response = getattr(self.requests_session, method)(url, headers=headers, **kwargs)
+            if not response.ok:
+                raise ClientError(
+                    response.status_code, response.json() if response.status_code == 400 else response.reason
+                )
+        except requests.ConnectionError:
+            raise ClientError(408, 'Server is not responding')
+
+        return response.json()
+
+    def _get(self, path, payload=None, url_conversion=None):
+        response = self._request('get', path, params=payload)
+        if url_conversion:
+            if url_conversion['is_list']:
+                files_url_to_path_from_objs(response['results'], **url_conversion)
+            else:
+                files_url_to_path_from_objs(response, **url_conversion)
+        return response
+
+    def _post(self, path, payload=None, files=None, params=None):
+        return self._request('post', path, data=payload, files=files, params=params)
+
+    def _patch(self, path, payload=None, files=None, params=None):
+        return self._request('patch', path, data=payload, files=files, params=params)
+
+    def _list(self, path, payload=None, url_conversion=None, list_all=False):
+        response = self._get(path, payload, url_conversion)
+        if list_all:
+            return self._list_all(path, payload, url_conversion), response['count']
+        else:
+            return response
+
+    def _list_all(self, path, payload=None, url_conversion=None):
+        response = self._get(path, payload, url_conversion)
+        yield from response['results']
+        if response['next']:
+            yield from self._list_all(response['next'], payload, url_conversion)

synapse/client/exceptions.py

@@ -0,0 +1,16 @@
+class ClientError(Exception):
+    status = None
+    reason = None
+
+    def __init__(self, status, reason, *args):
+        self.status = status
+        self.reason = reason
+        super().__init__(status, reason, *args)
+
+    def as_validation_error(self):
+        if self.status == 400:
+            error = self.reason
+        else:
+            error = str(self)
+
+        return {'backend_errors': error}

synapse/client/mixins/annotation.py

@@ -0,0 +1,28 @@
+from ..utils import get_default_url_conversion
+
+
+class AnnotationClientMixin:
+    def get_project(self, pk):
+        path = f'projects/{pk}/'
+        return self._get(path)
+
+    def get_label_tag(self, pk):
+        path = f'label_tags/{pk}/'
+        return self._get(path)
+
+    def list_label_tags(self, payload=None):
+        path = 'label_tags/'
+        return self._list(path, payload)
+
+    def list_labels(self, payload=None, url_conversion=None, list_all=False):
+        path = 'labels/'
+        url_conversion = get_default_url_conversion(url_conversion, files_fields=['files'])
+        return self._list(path, payload, url_conversion, list_all)
+
+    def create_labels(self, data):
+        path = 'labels/'
+        return self._post(path, payload=data)
+
+    def set_tags_labels(self, data, params=None):
+        path = 'labels/set_tags/'
+        return self._post(path, payload=data, params=params)

synapse/client/mixins/dataset.py

@@ -0,0 +1,48 @@
+from multiprocessing import Pool
+from tqdm import tqdm
+from ..utils import get_batched_list
+
+
+class DatasetClientMixin:
+    def list_dataset(self):
+        path = 'datasets/'
+        return self._get(path)
+
+    def create_data_file(self, file_path):
+        path = 'data_files/'
+        return self._post(path, files={'file': file_path})
+
+    def create_data_units(self, data):
+        path = 'data_units/'
+        return self._post(path, payload=data)
+
+    def import_dataset(self, dataset_id, dataset, project_id=None, batch_size=1000, process_pool=10):
+        # TODO validate datset with schema
+
+        params = [(data, dataset_id) for data in dataset]
+
+        with Pool(processes=process_pool) as pool:
+            dataset = pool.starmap(self.import_data_file, tqdm(params))
+
+        batches = get_batched_list(dataset, batch_size)
+
+        for batch in tqdm(batches):
+            data_units = self.create_data_units(batch)
+
+            if project_id:
+                labels_data = []
+                for data, data_unit in zip(batch, data_units):
+                    label_data = {'project': project_id, 'data_unit': data_unit['id']}
+                    if 'ground_truth' in data:
+                        label_data['ground_truth'] = data['ground_truth']
+
+                    labels_data.append(label_data)
+
+                self.create_labels(labels_data)
+
+    def import_data_file(self, data, dataset_id):
+        for name, path in data['files'].items():
+            data_file = self.create_data_file(path)
+            data['dataset'] = dataset_id
+            data['files'][name] = {'checksum': data_file['checksum'], 'path': str(path)}
+        return data

synapse/client/mixins/integration.py

@@ -0,0 +1,12 @@
+class IntegrationClientMixin:
+    def get_plugin(self, pk):
+        path = f'plugins/{pk}/'
+        return self._get(path)
+
+    def create_logs(self, data):
+        path = 'logs/'
+        return self._post(path, payload=data)
+
+    def create_task(self, data):
+        path = 'agent_tasks/'
+        return self._post(path, payload=data)

synapse/client/mixins/ml.py

@@ -0,0 +1,23 @@
+from ..utils import get_default_url_conversion
+
+
+class MLClientMixin:
+    def get_model(self, pk, payload=None, url_conversion=None):
+        path = f'models/{pk}/'
+        url_conversion = get_default_url_conversion(
+            url_conversion, files_fields=['files', 'parent.files'], is_list=False
+        )
+        return self._get(path, payload, url_conversion)
+
+    def create_model(self, data):
+        path = 'models/'
+        return self._post(path, payload=data)
+
+    def update_model(self, pk, data, files=None):
+        path = f'models/{pk}/'
+        return self._patch(path, payload=data, files=files)
+
+    def list_train_dataset(self, payload=None, url_conversion=None, list_all=False):
+        path = 'train_dataset/'
+        url_conversion = get_default_url_conversion(url_conversion, files_fields=['files'])
+        return self._list(path, payload, url_conversion, list_all)

synapse/client/utils.py

@@ -0,0 +1,10 @@
+def get_default_url_conversion(url_conversion, **kwargs):
+    defaults = {'files_fields': [], 'coerce': None, 'is_list': True}
+    defaults.update(kwargs)
+    if url_conversion:
+        defaults.update(url_conversion)
+    return defaults
+
+
+def get_batched_list(object_list, batch_size):
+    return [object_list[index : index + batch_size] for index in range(0, len(object_list), batch_size)]

synapse/config.py

@@ -0,0 +1,8 @@
+try:
+    from constance import config as constance_config
+
+    config = constance_config
+except ImportError:
+    config = None
+
+__all__ = ['config']

synapse/loggers.py

@@ -0,0 +1,48 @@
+import datetime
+
+from synapse.client import ClientError
+
+
+class BaseLogger:
+    progress_records = {}
+    logs_queue = []
+    client = None
+
+    def __init__(self, client=None, task=None):
+        self.client = client
+        self.task = task
+
+    def set_progress(self, current, total, category=''):
+        percent = 0
+        if total > 0:
+            percent = (current / total) * 100
+            percent = float(round(percent, 2))
+
+        self.progress_records[category] = {'current': current, 'total': total, 'percent': percent}
+        if self.task:
+            self.task.update_state(state='PROGRESS', meta=self.progress_records)
+        else:
+            print(self.progress_records)
+
+    def log(self, action, data):
+        log = {'action': action, 'data': data, 'datetime': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')}
+
+        if self.client and self.task:
+            log['task_id'] = self.task.request.id
+            self.logs_queue.append(log)
+            try:
+                self.client.create_logs(self.logs_queue)
+                self.logs_queue.clear()
+            except ClientError as e:
+                print(e)
+        else:
+            print(log)
+
+
+class ConsoleLogger(BaseLogger):
+    def log(self, action, data):
+        print(action, data)
+
+
+class SynapseLogger(BaseLogger):
+    pass

synapse/plugins/__init__.py

@@ -0,0 +1,32 @@
+import argparse
+
+from synapse.plugins.utils import get_action
+
+action = None
+
+
+def init():
+    global action
+    parser = argparse.ArgumentParser(description='synapse plugin runner')
+
+    # Add arguments
+    parser.add_argument('action', help='action to run on this plugin')
+    parser.add_argument('params', help='parameter of the action')
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Access parsed arguments
+    action = args.action
+    params = args.params
+
+    action = get_action(action, params)
+
+
+def run():
+    global action
+    assert action is not None
+    action.run()
+
+
+__all__ = ['init', 'run']

synapse/plugins/categories/__init__.py

@@ -0,0 +1,13 @@
+from synapse.plugins.categories.neural_net.actions.deployment import DeploymentAction
+from synapse.plugins.categories.neural_net.actions.inference import InferenceAction
+from synapse.plugins.categories.neural_net.actions.test import TestAction
+from synapse.plugins.categories.neural_net.actions.train import TrainAction
+
+ACTIONS = {
+    'neural_net': {
+        'deployment': DeploymentAction,
+        'inference': InferenceAction,
+        'train': TrainAction,
+        'test': TestAction,
+    },
+}

synapse/plugins/categories/base.py

@@ -0,0 +1,49 @@
+from functools import cached_property
+
+from synapse.loggers import ConsoleLogger
+from synapse.plugins.utils import get_plugin_checksum
+
+
+class Action:
+    params = None
+    config = None
+    client = None
+    logger = None
+
+    def __init__(self, params, config):
+        self.params = params
+        self.config = config
+
+        # TODO logger 지정 방식 개선
+        self.logger = ConsoleLogger()
+
+    @cached_property
+    def plugin_id(self):
+        code = self.config['code']
+        version = self.config['version']
+        return f'{code}@{version}'
+
+    @cached_property
+    def plugin_checksum(self):
+        return get_plugin_checksum(self.plugin_id)
+
+    def get_runtime_env(self):
+        return {
+            # TODO url기반 working_dir 가져오기
+            'working_dir': ''
+        }
+
+    def run(self):
+        raise NotImplementedError
+
+    def set_progress(self, current, total, category=''):
+        self.logger.set_progress(current, total, category)
+
+    def log(self, action, data):
+        self.logger.log(action, data)
+
+    def log_event(self, message):
+        self.logger.log('event', {'content': message})
+
+    def end_log(self):
+        self.log_event('Plugin run is complete.')

synapse/plugins/categories/neural_net/actions/deployment.py

@@ -0,0 +1,24 @@
+from ray import serve
+
+from synapse.plugins.categories.base import Action
+from synapse.utils.module_loading import import_string
+
+
+class DeploymentAction(Action):
+    deployment = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.deployment = self.get_deployment()
+
+    def get_deployment(self):
+        entrypoint = self.config['actions']['deployment']['entrypoint']
+        deployment = import_string(entrypoint)
+        return serve.deployment(ray_actor_options=self.get_actor_options())(deployment)
+
+    def get_actor_options(self):
+        return {'runtime_env': self.get_runtime_env()}
+
+    def run(self):
+        serve.delete(self.plugin_id)
+        serve.run(self.deployment.bind(), name=self.plugin_id, route_prefix=f'/{self.plugin_checksum}')

synapse/plugins/categories/neural_net/actions/test.py

@@ -0,0 +1,6 @@
+from synapse.plugins.categories.base import Action
+
+
+class TestAction(Action):
+    def run(self):
+        pass

synapse/plugins/categories/neural_net/actions/train.py

@@ -0,0 +1,91 @@
+from synapse.plugins.categories.base import Action
+from synapse.utils.file import get_dict_from_file, files_url_to_path_from_objs
+from synapse.utils.module_loading import import_string
+
+
+class TrainAction(Action):
+    # TODO implement specifying which hardware to use (gpu-n, cpu)
+
+    def get_input_dataset_for_training(self, model_id=None):
+        """
+        :return:
+        {
+            "train": [
+                {
+                    "files": {
+                        "image": {
+                            "path": "/path/to/image.jpg",
+                            "meta": {
+                                "width": 265,
+                                "height": 190,
+                                "created": 1651563526.0277045,
+                                "file_size": 5191,
+                                "last_modified": 1651563526.0277045
+                            }
+                        }
+                    },
+                    "ground_truth": {
+                        ...label_data
+                    }
+                },
+                ...
+            ],
+            "validation": ...,
+            "test": ...
+        }
+        """
+
+        client = self.logger.client
+        input_dataset = {}
+        category_int_to_str = {1: 'train', 2: 'validation', 3: 'test'}
+
+        if client:
+            train_dataset, count_dataset = client.list_train_dataset(
+                payload={'fields': ['category', 'files', 'ground_truth'], 'model': model_id}, list_all=True
+            )
+
+            for i, train_data in enumerate(train_dataset, start=1):
+                self.set_progress(i, count_dataset, category='dataset_download')
+                category = category_int_to_str[train_data.pop('category')]
+                try:
+                    input_dataset[category].append(train_data)
+                except KeyError:
+                    input_dataset[category] = [train_data]
+
+        else:
+            for category in category_int_to_str.values():
+                dataset_path = self.task['dataset'].get(category)
+                if dataset_path:
+                    input_dataset[category] = get_dict_from_file(dataset_path)
+                    files_url_to_path_from_objs(input_dataset[category], ['files'], is_list=True)
+
+        return input_dataset
+
+    def run_train(self):
+        hyperparameter = self.task['hyperparameter']
+        train = import_string(self.plugin['train']['entrypoint'])
+
+        # download dataset
+        self.log_event('Preparing dataset for training.')
+        input_dataset = self.get_input_dataset_for_training()
+
+        # train dataset
+        self.log_event('Starting model training.')
+
+        model_files = train(self, input_dataset, hyperparameter)
+
+        # upload model_data
+        self.log_event('Registering model data.')
+
+        self.end_log()
+        return model_files
+
+    def start(self):
+        action = self.task['action']
+        getattr(self, f'run_{action}')()
+
+    def log_metric(self, x, i, **kwargs):
+        self.log(x, {x: i, **kwargs})
+
+    def log_model(self, files, status=None):
+        pass

synapse/plugins/utils.py

@@ -0,0 +1,26 @@
+import json
+
+from synapse.utils.file import get_dict_from_file
+from synapse.utils.string import hash_text
+
+
+def get_action(action, json_or_path):
+    from synapse.plugins.categories import ACTIONS
+
+    try:
+        params = json.loads(json_or_path)
+    except json.JSONDecodeError:
+        params = get_dict_from_file(json_or_path)
+    config = get_dict_from_file('config.yaml')
+    category = config['category']
+    return ACTIONS[category][action](params, config)
+
+
+def get_available_actions(category):
+    from synapse.plugins.categories import ACTIONS
+
+    return list(ACTIONS[category].keys())
+
+
+def get_plugin_checksum(plugin_id):
+    return hash_text(plugin_id)

synapse/utils/file.py

@@ -0,0 +1,58 @@
+import json
+import operator
+from functools import reduce
+from pathlib import Path
+
+import requests
+import yaml
+
+
+def download_file(url, path_download, name=None, coerce=None):
+    if name:
+        name += Path(url).suffix
+    else:
+        name = Path(url).name
+
+    path = path_download / name
+    if not path.is_file():
+        r = requests.get(url, allow_redirects=True)
+        open(str(path), 'wb').write(r.content)
+
+    if coerce:
+        path = coerce(path)
+
+    return path
+
+
+def files_url_to_path(files, coerce=None):
+    path_download = Path('/tmp/datamaker') / 'media'
+    path_download.mkdir(parents=True, exist_ok=True)
+    for file_name in files:
+        if isinstance(files[file_name], str):
+            files[file_name] = download_file(files[file_name], path_download, coerce=coerce)
+        else:
+            files[file_name]['path'] = download_file(files[file_name].pop('url'), path_download, coerce=coerce)
+
+
+def files_url_to_path_from_objs(objs, files_fields, coerce=None, is_list=False):
+    if not is_list:
+        objs = [objs]
+
+    for obj in objs:
+        for files_field in files_fields:
+            try:
+                files = reduce(operator.getitem, files_field.split('.'), obj)
+                files_url_to_path(files, coerce=coerce)
+            except KeyError:
+                pass
+
+
+def get_dict_from_file(file_path):
+    if isinstance(file_path, str):
+        file_path = Path(file_path)
+
+    with open(file_path) as f:
+        if file_path.suffix == '.yaml':
+            return yaml.safe_load(f)
+        else:
+            return json.load(f)

synapse/utils/module_loading.py

@@ -0,0 +1,29 @@
+import sys
+from importlib import import_module
+
+
+def cached_import(module_path, class_name):
+    # Check whether module is loaded and fully initialized.
+    if not (
+        (module := sys.modules.get(module_path))
+        and (spec := getattr(module, '__spec__', None))
+        and getattr(spec, '_initializing', False) is False
+    ):
+        module = import_module(module_path)
+    return getattr(module, class_name)
+
+
+def import_string(dotted_path):
+    """
+    Import a dotted module path and return the attribute/class designated by the
+    last name in the path. Raise ImportError if the import failed.
+    """
+    try:
+        module_path, class_name = dotted_path.rsplit('.', 1)
+    except ValueError as err:
+        raise ImportError("%s doesn't look like a module path" % dotted_path) from err
+
+    try:
+        return cached_import(module_path, class_name)
+    except AttributeError as err:
+        raise ImportError('Module "%s" does not define a "%s" attribute/class' % (module_path, class_name)) from err

synapse/utils/string.py

@@ -0,0 +1,7 @@
+import hashlib
+
+
+def hash_text(text):
+    md5_hash = hashlib.md5()
+    md5_hash.update(text.encode('utf-8'))
+    return md5_hash.hexdigest()

synapse_sdk-0.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 PerhapsSPY and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

synapse_sdk-0.0.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: synapse-sdk
+Version: 0.0.0
+Summary: synapse sdk
+Author-email: datamaker <developer@datamaker.io>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: tqdm
+Requires-Dist: pyyaml
+Requires-Dist: pydantic
+Requires-Dist: ray[all]
+

synapse_sdk-0.0.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+synapse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/config.py,sha256=AHyTHtzkkCZb9DLu1_R99VOwPgWATZj4K7yzHaPijfA,149
+synapse/loggers.py,sha256=xFZl1sHffhRShtZoTwlNG7zAtkrG9FDxZDMz8xdvzyg,1327
+synapse/client/__init__.py,sha256=zX2xGXMkcXLQ0zs96K6oQYvNkMlh4P1Xpmw-fvg6MEE,3400
+synapse/client/exceptions.py,sha256=LzgzPKRPhNUpLh-jBQHKze8c3CQoVA22jSfjUMBZCuU,405
+synapse/client/utils.py,sha256=8pPJTdzHiRPSbZMoQYHAgR2BAMO6u_R_jMV6a2p34iQ,392
+synapse/client/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/client/mixins/annotation.py,sha256=69xblc0RLokKlpSfIzoJ5dVRvw3VpPIVgbQKV3L5Xx4,905
+synapse/client/mixins/dataset.py,sha256=KXsen7-vdSzdR09uxD88lT604ItJKuCOSLR3fEU5ud0,1666
+synapse/client/mixins/integration.py,sha256=LfMgPsP_OBNCZmSTpEThlLcSnOHv1-H8EhhryPNriCE,336
+synapse/client/mixins/ml.py,sha256=xkfO95k6p_nQVyai2zBO-z4b9nh6YIryN4iakDGiPsE,891
+synapse/plugins/__init__.py,sha256=OCcxzbGsQ68zPbz3Nyd21_oqL1W9ocJU_e5wNbS9wUc,623
+synapse/plugins/utils.py,sha256=G5Ife0tveVbKpMjAI7sBFTLO5Kul8sAS--SFhlMy_1M,669
+synapse/plugins/categories/__init__.py,sha256=ejRSvoJUhz1SrBaH43nuyOjlydebg1o7hymvUDS1Pik,498
+synapse/plugins/categories/base.py,sha256=20T-ZIH-MVYc3EgJgb804bR4_gven6rBBmGNw2XEdn4,1216
+synapse/plugins/categories/custom_script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/custom_script/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/export/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/import/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/import/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/neural_net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/neural_net/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/plugins/categories/neural_net/actions/deployment.py,sha256=B86zjVbxLO7WsSqPGNgReTetAilt2wRj4VI3TS38UXo,805
+synapse/plugins/categories/neural_net/actions/test.py,sha256=XX2dcwNAEkn7mFliwPb70cx7wn0LL_QcDQ7EW6n-H2w,111
+synapse/plugins/categories/neural_net/actions/train.py,sha256=lQvqVyC8lqVcs8x6v4bD1vTQyDrUz15gSiodEOPGcQc,3100
+synapse/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+synapse/utils/file.py,sha256=kwNoOAzJqT6v2fBHUhhs9sW2mdziUJmYHOxPzIodhmE,1578
+synapse/utils/module_loading.py,sha256=chHpU-BZjtYaTBD_q0T7LcKWtqKvYBS4L0lPlKkoMQ8,1020
+synapse/utils/string.py,sha256=FMH1vlh7BsDcawCiov3HtQEcjp3KSHmjcZ2wZ9EeGu0,141
+synapse_sdk-0.0.0.dist-info/LICENSE,sha256=bKzmC5YAg4V1Fhl8OO_tqY8j62hgdncAkN7VrdjmrGk,1101
+synapse_sdk-0.0.0.dist-info/METADATA,sha256=faVVxD94nPEHfNSmSZ2ZDYGtW7pMZcUkgHeMWyM5vpg,387
+synapse_sdk-0.0.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+synapse_sdk-0.0.0.dist-info/top_level.txt,sha256=v_1YsqjmoSCzCKs7oIhzTNmWtSYoORiBMv1TJkOhx8A,8
+synapse_sdk-0.0.0.dist-info/RECORD,,

synapse_sdk-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

synapse_sdk-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+synapse