pybioos 0.0.3__py3-none-any.whl

bioos/tests/workflows.py

@@ -0,0 +1,287 @@
+import time
+from unittest import mock
+from unittest.mock import patch
+
+import pandas
+from pandas import DataFrame
+
+from bioos import bioos
+from bioos.errors import ConflictError
+from bioos.service.BioOsService import BioOsService
+from bioos.tests.base import BaseInit
+
+
+class TestWorkflows(BaseInit):
+    cluster_id = "default"
+
+    workflow_name = "hello-test"
+    workflow_id = "fake_workflow_id"
+
+    data_model_name = "my_entity"
+    data_model_id = "fake_data_model_id"
+
+    submission_id = "fake_submission_id"
+    run_id = "fake_run_id"
+
+    list_workspace_val = {
+        'Items':
+            [{'ID': BaseInit.workspace_id, 'Name': 'test-gqm',
+              'Description': 'test-gqm', 'CreateTime': 1661326698,
+              'UpdateTime': 1661326698, 'OwnerName': 'test',
+              'CoverDownloadURL':
+                  'https://fake.tos-s3-cn-beijing.volces.com/template-cover/pic7.png?XXXXXXXXXXXX',
+              'Role': 'Admin', 'S3Bucket': 'bioos-dev-fake-workspace'}],
+        'PageNumber': 1, 'PageSize': 10, 'TotalCount': 1}
+
+    list_workflows_val = {'Items': [
+        {'ID': workflow_id, 'Name': workflow_name, 'Description': '[dockstore]',
+         'CreateTime': 1670929870, 'UpdateTime': 1671032374, 'Language': 'WDL',
+         'Source': 'https://github.com/fake/hello.git', 'Tag': 'main',
+         'MainWorkflowPath': 'hello.wdl',
+         'Status': {'Phase': 'Failed',
+                    'Message': 'job failed: Reason=BackoffLimitExceeded, '
+                               'Message=Job has reached the specified backoff limit; '
+                               'failed to getJobLogs: invalid number of pods: 0'}}
+    ], 'Total': 1}
+
+    list_data_models_val = {'Total': 1, 'Items': [
+        {'ID': data_model_id, 'Name': data_model_name, 'RowCount': 162, 'Type': 'normal'},
+    ]}
+
+    workflow_env_info = {
+        'Items':
+            [{'ClusterInfo':
+                  {'ID': 'default',
+                   'Name': 'Volcengine Container Cluster',
+                   'Status': 'Running',
+                   'StartTime': 1668596478,
+                   'Description': 'Default Volcengine Container Cluster',
+                   'Bound': True,
+                   'Public': True,
+                   'ExternalConfig': {
+                       'WESEndpoint': 'http://localhost:8080/ga4gh/wes/v1',
+                       'JupyterhubEndpoint': 'http://jupyterhub.fake.com/jupyterhub',
+                       'JupyterhubJWTSecret': '',
+                       'ResourceScheduler': 'Kubernetes',
+                       'Filesystem': 'tos'}},
+              'Type': 'workflow', 'BindTime': 1676534060}], 'TotalCount': 1
+    }
+
+    list_submission_val = {
+        'Items': [{'ID': 'fake_submission_id', 'Name': 'hello-history-2022-12-21-16-54-29',
+                   'Description': 'gqm-test-sdk', 'Status': 'Failed',
+                   'RunStatus': {'Count': 3, 'Succeeded': 0, 'Failed': 3,
+                                 'Running': 0}, 'StartTime': 1671612870,
+                   'FinishTime': 1671613042, 'Duration': 172, 'WorkflowID':
+                       'fcegt1vleig4f5465sofg', 'ClusterID': 'default',
+                   'DataModelID': 'fake_data_model_id',
+                   'Inputs': '{"testname.hello.name":"this.date"}',
+                   'Outputs': '{"testname.hello.response":"this.response1"}',
+                   'ExposedOptions': {'ReadFromCache': False,
+                                      'ExecutionRootDir': 's3://bioos-dev-fake-workspace'},
+                   'OwnerName': 'test'}], 'PageNumber': 1, 'PageSize': 10, 'TotalCount': 1}
+
+    finished_list_runs_val = {'Total': 1, 'Items': [
+        {'ID': run_id, 'DataEntityRowID': 'your-sample-3-id', 'Status': 'Failed',
+         'StartTime': 1671612870, 'FinishTime': 1671613042, 'Duration': 172,
+         'SubmissionID': 'fake_submission_id',
+         'EngineRunID': 'd0da2939-8d12-4ba3-9872-529677a39da9',
+         'Inputs': '{"testname.hello.name":"01/01/2022"}', 'Outputs': '',
+         'TaskStatus': {'Succeeded': 0, 'Failed': 1, 'Running': 0},
+         'Log': 's3://bioos-dev-fake-workspace/analysis/fake_submission_id'
+                '/workflow.d0da2939-8d12-4ba3-9872-529677a39da9.log',
+         'Message': 'workflow run failed: [{"causedBy":[{"causedBy":[],"message":"Task '
+                    'testname.hello:NA:1 failed for unknown reason: FailedOrError"}],'
+                    '"message":"Workflow failed"}]'
+         }]}
+
+    list_run_val = {'Total': 1, 'Items': [
+        {'ID': run_id, 'DataEntityRowID': 'your-sample-3-id', 'Status': 'Running',
+         'StartTime': 1671612870, 'Duration': 0, 'SubmissionID': 'fake_submission_id',
+         'EngineRunID': None, 'Inputs': '{"testname.hello.name":"01/01/2022"}', 'Outputs': ''}]}
+
+    list_tasks_val = {'Total': 0, 'Items': []}
+    finished_list_tasks_val = {'Total': 1, 'Items': [
+        {'Name': 'testname.hello', 'RunID': run_id, 'Status': 'Failed', 'StartTime': 1671612876,
+         'FinishTime': 1671613037, 'Duration': 161,
+         'Log': 's3://bioos-dev-fake-workspace/analysis/fake_submission_id/testname'
+                '/d0da2939-8d12-4ba3-9872-529677a39da9/call-hello/execution/log',
+         'Stdout': 's3://bioos-dev-fake-workspace/analysis/fake_submission_id/testname'
+                   '/d0da2939-8d12-4ba3-9872-529677a39da9/call-hello/execution/stdout',
+         'Stderr': 's3://bioos-dev-fake-workspace/analysis/fake_submission_id/testname'
+                   '/d0da2939-8d12-4ba3-9872-529677a39da9/call-hello/execution/stderr'}]}
+
+    def __init__(self, *args, **kwargs):
+        super(TestWorkflows, self).__init__(*args, **kwargs)
+        ws = bioos.workspace(self.workspace_id)
+        with patch.object(BioOsService, "list_workspaces",
+                          return_value=self.list_workspace_val):
+            with patch.object(BioOsService, "list_workflows",
+                              return_value=self.list_workflows_val):
+                self.workflows = ws.workflows
+                self.workflow = ws.workflow(self.workflow_name)
+        # XXX: wait for a while to make cache overdue
+        time.sleep(2)
+
+    def test_workflows_repr(self):
+        with patch.object(BioOsService, "list_workflows",
+                          return_value=self.list_workflows_val) as success_list_workflows:
+            with patch.object(BioOsService, "list_cluster",
+                              return_value=self.workflow_env_info) as success_list_cluster:
+                # makes no call
+                self.workflows
+                # call list_workflows once and list_cluster twice
+                repr(self.workflows)
+                # make another call of list_workflows
+                list_res = self.workflows.list()
+                pandas.testing.assert_frame_equal(list_res, DataFrame.from_records([
+                    {'ID': self.workflow_id, 'Name': self.workflow_name,
+                     'Description': '[dockstore]',
+                     'CreateTime': pandas.to_datetime(1670929870,
+                                                      unit='ms',
+                                                      origin=pandas.Timestamp('2018-07-01')),
+                     'UpdateTime': pandas.to_datetime(1671032374,
+                                                      unit='ms',
+                                                      origin=pandas.Timestamp('2018-07-01')),
+                     'Language': 'WDL', 'Source': 'https://github.com/fake/hello.git',
+                     'Tag': 'main', 'MainWorkflowPath': 'hello.wdl'}
+                ]))
+                success_list_workflows.assert_has_calls([
+                    mock.call({
+                        'WorkspaceID': self.workspace_id,
+                        'SortBy': 'CreateTime',
+                        'PageSize': 0,
+                    }),
+                    mock.call({
+                        'WorkspaceID': self.workspace_id,
+                        'SortBy': 'CreateTime',
+                        'PageSize': 0,
+                    }),
+                ])
+                success_list_cluster.assert_has_calls([
+                    mock.call(params={
+                        'Type': "workflow",
+                        "ID": self.workspace_id
+                    })
+                ])
+
+    def test_import_and_delete(self):
+        with patch.object(BioOsService, "check_workflow",
+                          return_value={'IsNameExist': False}) as success_check:
+            with patch.object(BioOsService, "create_workflow",
+                              return_value={'ID': self.workflow_id}) as success_create:
+                workflow_id = self.workflows.import_workflow("https://github.com/fake/hello.git",
+                                                             self.workflow_name, "WDL", "main",
+                                                             "hello.wdl", "[dockstore]")
+                self.assertEqual(workflow_id, self.workflow_id)
+        success_check.assert_called_once_with({
+            "WorkspaceID": self.workspace_id,
+            "Name": self.workflow_name,
+        })
+        success_create.assert_called_once_with({
+            "WorkspaceID": self.workspace_id,
+            "Name": self.workflow_name,
+            "Description": "[dockstore]",
+            "Language": "WDL",
+            "Source": "https://github.com/fake/hello.git",
+            "Tag": "main",
+            "MainWorkflowPath": "hello.wdl",
+        })
+
+        with patch.object(BioOsService, "check_workflow",
+                          return_value={'IsNameExist': True}) as success_check:
+            with patch.object(BioOsService, "create_workflow") as miss_create:
+                try:
+                    self.workflows.import_workflow("https://github.com/fake/hello.git",
+                                                   self.workflow_name, "WDL", "main", "hello.wdl",
+                                                   "[dockstore]")
+                except ConflictError as e:
+                    self.assertEqual(e.message, f"parameter 'name' conflicts: "
+                                                f"{self.workflow_name} already exists")
+        success_check.assert_called_once_with({
+            "WorkspaceID": self.workspace_id,
+            "Name": self.workflow_name,
+        })
+        miss_create.assert_not_called()
+
+        with patch.object(BioOsService, "delete_workflow") as success_delete:
+            with patch.object(BioOsService, "list_workflows",
+                              return_value=self.list_workflows_val):
+                with patch.object(BioOsService, "list_cluster",
+                                  return_value=self.workflow_env_info):
+                    self.workflows.delete(self.workflow_name)
+
+        success_delete.assert_called_once_with({
+            "WorkspaceID": self.workspace_id,
+            "ID": self.workflow_id
+        })
+
+    def test_submit(self):
+        with patch.object(BioOsService, "list_cluster",
+                          return_value=self.workflow_env_info) as list_cluster:
+            with patch.object(BioOsService, "list_workflows",
+                              return_value=self.list_workflows_val) as list_workflows:
+                with patch.object(BioOsService, "list_data_models",
+                                  return_value=self.list_data_models_val) as list_data_models:
+                    with patch.object(BioOsService, "create_submission",
+                                      return_value={
+                                          'ID': self.submission_id}) as create_submission:
+                        with patch.object(BioOsService, "list_submissions",
+                                          return_value=self.list_submission_val) as list_submissions:
+                            with patch.object(BioOsService, "list_tasks",
+                                              return_value=self.list_tasks_val) as list_tasks:
+                                with patch.object(BioOsService, "list_runs",
+                                                  return_value=self.list_run_val) as list_runs:
+                                    runs = self.workflow.submit(
+                                        data_model_name=self.data_model_name,
+                                        row_ids=[
+                                            "your-sample-3-id"
+                                        ],
+                                        inputs='{"testname.hello.name":"this.name1"}',
+                                        outputs='{"testname.hello.response":"this.response1"}',
+                                        submission_desc="gqm-test-sdk",
+                                        call_caching=False)
+                                    self.assertEqual(len(runs), 1)
+                                    run = runs[0]
+                                    self.assertEqual(run.submission, self.submission_id)
+                                    self.assertEqual(run.id, self.run_id)
+        list_cluster.assert_called_once()
+        list_workflows.assert_called_once_with({
+            'WorkspaceID': self.workspace_id,
+            'SortBy': 'CreateTime',
+            'PageSize': 0,
+        })
+        list_data_models.assert_has_calls([
+            mock.call({
+                'WorkspaceID': self.workspace_id
+            }), mock.call({
+                'WorkspaceID': self.workspace_id
+            })
+        ])
+        # list_data_models.assert_called_once()
+        create_submission.assert_called_once()
+        # list_runs.assert_called_once()
+        list_submissions.assert_called_once()
+        list_tasks.assert_not_called()
+        list_runs.assert_has_calls([
+            mock.call({
+                'WorkspaceID': self.workspace_id,
+                'SubmissionID': self.submission_id,
+                'PageSize': 0
+            }), mock.call({
+                'WorkspaceID': self.workspace_id,
+                'Filter': {'IDs': ['fake_run_id']},
+            }), mock.call({
+                'WorkspaceID': self.workspace_id,
+                'SubmissionID': self.submission_id,
+            })
+        ])
+        # wait for a while to make cache overdue
+        time.sleep(2)
+        with patch.object(BioOsService, "list_runs",
+                          return_value=self.finished_list_runs_val) as list_runs:
+            with patch.object(BioOsService, "list_tasks",
+                              return_value=self.finished_list_tasks_val) as list_tasks:
+                repr(run)
+        list_runs.assert_called_once()
+        list_tasks.assert_called_once()

bioos/tests/workspaces.py

@@ -0,0 +1,115 @@
+from datetime import datetime
+from unittest import mock
+from unittest.mock import patch
+
+import pandas.testing
+from pandas import DataFrame
+
+from bioos import bioos
+from bioos.service.BioOsService import BioOsService
+from bioos.tests.base import BaseInit
+
+
+class TestWorkspaces(BaseInit):
+    list_workspace_val = {
+        'Items':
+            [{'ID': BaseInit.workspace_id, 'Name': 'test-gqm',
+              'Description': 'test-gqm', 'CreateTime': 1661326698,
+              'UpdateTime': 1661326698, 'OwnerName': 'test',
+              'CoverDownloadURL':
+                  'https://fake.tos-s3-cn-beijing.volces.com/template-cover/pic7.png?XXXXXXXXXXXX',
+              'Role': 'Admin', 'S3Bucket': 'bioos-dev-fake-workspace'}],
+        'PageNumber': 1, 'PageSize': 10, 'TotalCount': 1}
+    notebook_env_info = {
+        'Items':
+            [{'ClusterInfo':
+                  {'ID': 'default',
+                   'Name': 'Volcengine Container Cluster',
+                   'Status': 'Running',
+                   'StartTime': 1668596478,
+                   'Description': 'Default Volcengine Container Cluster',
+                   'Bound': True,
+                   'Public': True,
+                   'ExternalConfig': {
+                       'WESEndpoint': 'http://localhost:8080/ga4gh/wes/v1',
+                       'JupyterhubEndpoint': 'http://jupyterhub.fake.com/jupyterhub',
+                       'JupyterhubJWTSecret': '',
+                       'ResourceScheduler': 'Kubernetes',
+                       'Filesystem': 'tos'}},
+              'Type': 'notebook', 'BindTime': 1676534060}], 'TotalCount': 1
+    }
+    workflow_env_info = {
+        'Items':
+            [{'ClusterInfo':
+                  {'ID': 'default',
+                   'Name': 'Volcengine Container Cluster',
+                   'Status': 'Running',
+                   'StartTime': 1668596478,
+                   'Description': 'Default Volcengine Container Cluster',
+                   'Bound': True,
+                   'Public': True,
+                   'ExternalConfig': {
+                       'WESEndpoint': 'http://localhost:8080/ga4gh/wes/v1',
+                       'JupyterhubEndpoint': 'http://jupyterhub.fake.com/jupyterhub',
+                       'JupyterhubJWTSecret': '',
+                       'ResourceScheduler': 'Kubernetes',
+                       'Filesystem': 'tos'}},
+              'Type': 'workflow', 'BindTime': 1676534060}], 'TotalCount': 1
+    }
+
+    def list_cluster_side_effect(self, params):
+        if params.get("Type") == "notebook":
+            return self.notebook_env_info
+        else:
+            return self.workflow_env_info
+
+    def __init__(self, *args, **kwargs):
+        super(TestWorkspaces, self).__init__(*args, **kwargs)
+        self.ws = bioos.workspace(self.workspace_id)
+
+    def test_singleton(self):
+        ws = bioos.workspace(self.workspace_id)
+        self.assertEqual(self.ws, ws)
+
+    def test_repr_info_and_cache_call(self):
+        with patch.object(BioOsService, "list_workspaces",
+                          return_value=self.list_workspace_val) as success_list_workspaces:
+            with patch.object(BioOsService, "list_cluster",
+                              side_effect=self.list_cluster_side_effect) as success_list_cluster:
+                # makes no call
+                self.ws.data_models
+                # call get_workspace and list_cluster once
+                repr(self.ws)
+                basic_info = self.ws.basic_info
+                env_info = self.ws.env_info
+                self.assertEqual(basic_info["name"],
+                                 self.list_workspace_val.get("Items")[0].get('Name'))
+                self.assertEqual(basic_info["description"],
+                                 self.list_workspace_val.get("Items")[0].get('Description'))
+                self.assertEqual(basic_info["s3_bucket"],
+                                 self.list_workspace_val.get("Items")[0].get("S3Bucket"))
+                self.assertEqual(basic_info["owner"],
+                                 self.list_workspace_val.get("Items")[0].get("OwnerName"))
+                self.assertEqual(basic_info["create_time"],
+                                 datetime.fromtimestamp(
+                                     self.list_workspace_val.get("Items")[0].get("CreateTime"))
+                                 )
+
+                pandas.testing.assert_frame_equal(env_info, DataFrame.from_records([
+                    {"cluster_id": "default", "name": "Volcengine Container Cluster",
+                     "description": "Default Volcengine Container Cluster", "type": "notebook"},
+                    {"cluster_id": "default", "name": "Volcengine Container Cluster",
+                     "description": "Default Volcengine Container Cluster", "type": "workflow"},
+                ]))
+
+        success_list_workspaces.assert_called_once_with({"Filter": {"IDs": [self.workspace_id]}})
+        success_list_cluster.assert_has_calls([
+            mock.call(params={
+                'Type': "notebook",
+                "ID": self.workspace_id}
+            ),
+            mock.call(params={
+                'Type': "workflow",
+                "ID": self.workspace_id}
+            )
+        ])

bioos/utils/common_tools.py

@@ -0,0 +1,57 @@
+import json
+import threading
+
+
+# helper_convert_pattern1 = re.compile(r'(.)([A-Z][a-z]+)')
+# helper_convert_pattern2 = re.compile(r'([a-z0-9])([A-Z])')
+#
+#
+# def camel_to_snake(case: str) -> str:
+#     return helper_convert_pattern2.sub(
+#         r'\1_\2',
+#         helper_convert_pattern1.sub(
+#             r'\1_\2',
+#             case
+#         )
+#     ).lower()
+
+
+def dict_str(dic: dict) -> str:
+    res_str = ""
+    for k, v in dic.items():
+        res_str += f"{k}: {v}\n"
+    return res_str
+
+
+def s3_endpoint_mapping(s3_endpoint: str) -> str:
+    return s3_endpoint.replace("tos-s3", "tos")
+
+
+def is_json(myjson: str):
+    try:
+        json.loads(myjson)
+    except ValueError:
+        return False
+    return True
+
+
+def submission_name(workflow_name, submission_name_suffix):
+    return '{}-history-{}'.format(workflow_name, submission_name_suffix)
+
+
+def instance_key(cls, *args, **kwargs):
+    return cls.__name__ + "%" + str(args) + "%" + str(kwargs)
+
+
+class SingletonType(type):
+    _instance_lock = threading.RLock()
+
+    def __call__(cls, *args, **kwargs):
+        if not hasattr(cls, "_instance"):
+            cls._instance = {}
+        key = instance_key(cls, *args, **kwargs)
+        if key not in getattr(cls, "_instance").keys():
+            with SingletonType._instance_lock:
+                if key not in getattr(cls, "_instance").keys():
+                    cls._instance[key] = super(SingletonType, cls).__call__(*args, **kwargs)
+        return cls._instance[key]

bioos/utils/workflows.py

@@ -0,0 +1,2 @@
+def submission_name(workflow_name, submission_name_suffix):
+    return '{}-history-{}'.format(workflow_name, submission_name_suffix)

pybioos-0.0.3.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 GBA-BI
+
+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.

pybioos-0.0.3.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: pybioos
+Version: 0.0.3
+Summary: BioOs SDK for Python
+Home-page: https://github.com/GBA-BI/pybioos
+Author: Jilong Liu
+Author-email: liu_jilong@gzlab.ac.cn
+License: MIT Licence
+Keywords: pip,bioos
+Platform: any
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+License-File: LICENSE
+Requires-Dist: volcengine >=1.0.61
+Requires-Dist: tabulate >=0.8.10
+Requires-Dist: click >=8.0.0
+Requires-Dist: pandas >=1.3.0
+Requires-Dist: tos ==2.3.4
+Requires-Dist: cachetools >=5.2.0
+Requires-Dist: typing-extensions >=4.4.0
+Requires-Dist: apscheduler >=3.10.4
+

pybioos-0.0.3.dist-info/RECORD

@@ -0,0 +1,38 @@
+bioos/__about__.py,sha256=BHwVVBX9xSoN_4elSOrXO8yb5rdj4AGsueI3EY6_FcA,56
+bioos/__init__.py,sha256=4GZKi13lDTD25YBkGakhZyEQZWTER_OWQMNPoH_UM2c,22
+bioos/bioos.py,sha256=fHzOb1l5wYxw6NVYYZDiFcgk4V28BAgWEc3ev12reWs,2409
+bioos/bioos_workflow.py,sha256=vdL8GVgYICetmqKkXIa3lu8hZRzWfdP_lzX_1HSHluE,9606
+bioos/config.py,sha256=L0CVtN2hpW8b-0xkLpGkTKgZsCqEZkhYVAwbRQDs0MI,4231
+bioos/errors.py,sha256=Lzz2rkjDOTR2X9CnVkmsmqeOgmNqbi46WAxnC6LEGm0,2459
+bioos/log.py,sha256=twiCvf5IgJB7uvzANwBluSlztJN8ZrxbGZUBGlZ0vps,3204
+bioos/internal/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bioos/internal/tos.py,sha256=bIb-nDuW6SCw8sBUk9bdB9GXw0oQi5kU_ARC4VCuLHA,11985
+bioos/models/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bioos/models/models.py,sha256=HPCLZ4jK2HDth4vrlVHba21CiW6y7y5im1kOjV4adc8,391
+bioos/resource/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bioos/resource/data_models.py,sha256=enKp8yyQI8IbRqe--0Xtyg1XzOwQQPQzoQsx_hNuZ6E,5089
+bioos/resource/files.py,sha256=TshetJeDU_pUQ-2jMbUnas6PARW_cCyjSP7mz0y0SPE,7847
+bioos/resource/utility.py,sha256=emY7qVLLLvGmQYlVj-_bLAxU7i1GfQOUybdRkfEDwVA,1300
+bioos/resource/workflows.py,sha256=06e9KS3Bm73mh9U6cDI7g8TmReM62EcgIjAxPGaqXaw,19541
+bioos/resource/workspaces.py,sha256=Gmr8y_sjK7TQbhMhQ_7rxqR1KFcwU72I95YYCFrrLBQ,3995
+bioos/service/BioOsService.py,sha256=HuYUEwomHCLpA1MYgVqGyWAQWHM-_BHB-jmy9VsOlnQ,6724
+bioos/service/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bioos/service/api.py,sha256=Khihn187bACEfBcJ-tRS9JO29-VCBsH0-9qq-i5WxkQ,8737
+bioos/service/config.py,sha256=FbBsb6CpcLsQZH7n8uuUbFVhkpqYOEnOe0xGkA7ZrjA,1009
+bioos/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bioos/tests/base.py,sha256=B7jSiMTkSN0wv1oVqtwlW8QuKMbrmEIZgXH1jxx1EsU,606
+bioos/tests/bioos.py,sha256=tq6S9OcVqwmQ2V9qa7swRL1-IytwYC5P4buW1Sy-5Q0,1836
+bioos/tests/data_models.py,sha256=rcj1-XooBIjkGHd8zrzRC0IlL9IVBj_sis8lbqv7Xrg,13641
+bioos/tests/files.py,sha256=YgT0N1VdvmFVldtdqepAUkJQvEeuw_g3Ft9wul1rs2c,6926
+bioos/tests/utils.py,sha256=PZ4e1AtU4Mt5Z8eSC1vda26pPE2ODghhAmICOlkl550,1472
+bioos/tests/workflows.py,sha256=N70oWeSb8-7UcDqVP7e6oJ2QyDG1beA6_GWQy7EOyNo,14557
+bioos/tests/workspaces.py,sha256=LuuRrTs2XqfE5mGQyJNl9RBtuMb4NZHBJFoO8HMZVYQ,5229
+bioos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bioos/utils/common_tools.py,sha256=a8xABCtmPS3DT7zh5bs_yRR-upDNmooO-ZpwVukJ0Rk,1488
+bioos/utils/workflows.py,sha256=zRbwTUigoM5V5LFOgzQPm3kwxt5Ogz95OFfefJc6Fjo,133
+pybioos-0.0.3.dist-info/LICENSE,sha256=cPkGXsgfPgEhIns7Lt3Avxx0Uy-VbdsoP8jvNGuj3cE,1063
+pybioos-0.0.3.dist-info/METADATA,sha256=62FUtlPrricJ59qHOQ_r3UG5IqkJ3VCbbOH-pN1E_2Y,770
+pybioos-0.0.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+pybioos-0.0.3.dist-info/entry_points.txt,sha256=8TRx1zyu7ja3x5RNaeFxeiYTj_-tiWydbuSulxi3TM0,59
+pybioos-0.0.3.dist-info/top_level.txt,sha256=llpzydkKVDSaWZgz3bsTUsQmhoQpc_JcRJg2-H-5a2U,6
+pybioos-0.0.3.dist-info/RECORD,,

pybioos-0.0.3.dist-info/WHEEL

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

pybioos-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bw = bioos.bioos_workflow:bioos_workflow

pybioos-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+bioos