pybiolib 1.1.1974__tar.gz → 1.1.1979__tar.gz

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybiolib
-Version: 1.1.1974
+Version: 1.1.1979
 Summary: BioLib Python Client
 Home-page: https://github.com/biolib
 License: MIT

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/biolib/app/app.py

@@ -1,29 +1,26 @@
-import os
 import io
-import random
 import json
+import os
+import random
 import string
-
 from pathlib import Path
+
 from biolib import utils
-from biolib.compute_node.job_worker.job_storage import JobStorage
-from biolib.compute_node.job_worker.job_worker import JobWorker
-from biolib.experiments.experiment import Experiment
-from biolib.jobs import Job
-from biolib.typing_utils import Optional, cast
-from biolib.biolib_api_client import CreatedJobDict, JobState
-from biolib.jobs.types import JobDict
+from biolib.biolib_api_client import JobState
 from biolib.biolib_api_client.app_types import App, AppVersion
-from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
 from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
+from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
 from biolib.biolib_binary_format import ModuleInput
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger
+from biolib.compute_node.job_worker.job_worker import JobWorker
+from biolib.experiments.experiment import Experiment
+from biolib.jobs import Job
+from biolib.typing_utils import Optional
 from biolib.utils.app_uri import parse_app_uri
 
 
 class BioLibApp:
-
     def __init__(self, uri: str):
         app_response = BiolibAppApi.get_by_uri(uri)
         self._app: App = app_response['app']
@@ -48,17 +45,17 @@ class BioLibApp:
         return self._app_version
 
     def cli(
-            self,
-            args=None,
-            stdin=None,
-            files=None,
-            override_command=False,
-            machine='',
-            blocking: bool = True,
-            experiment_id: Optional[str] = None,
-            result_prefix: Optional[str] = None,
-            timeout: Optional[int] = None,
-            notify: bool = False,
+        self,
+        args=None,
+        stdin=None,
+        files=None,
+        override_command=False,
+        machine='',
+        blocking: bool = True,
+        experiment_id: Optional[str] = None,
+        result_prefix: Optional[str] = None,
+        timeout: Optional[int] = None,
+        notify: bool = False,
     ) -> Job:
         if not experiment_id:
             experiment = Experiment.get_experiment_in_context()
@@ -78,7 +75,9 @@ class BioLibApp:
 
             return self._run_locally(module_input_serialized)
 
-        job = self._start_in_cloud(
+        job = Job._start_job_in_cloud(  # pylint: disable=protected-access
+            app_uri=self._app_uri,
+            app_version_uuid=self._app_version['public_id'],
             experiment_id=experiment_id,
             machine=machine,
             module_input_serialized=module_input_serialized,
@@ -93,8 +92,8 @@ class BioLibApp:
                 utils.STREAM_STDOUT = True
 
             enable_print = bool(
-                utils.STREAM_STDOUT and
-                (self._app_version.get('main_output_file') or self._app_version.get('stdout_render_type') == 'text')
+                utils.STREAM_STDOUT
+                and (self._app_version.get('main_output_file') or self._app_version.get('stdout_render_type') == 'text')
             )
             job._stream_logs(enable_print=enable_print)  # pylint: disable=protected-access
 
@@ -108,11 +107,11 @@ class BioLibApp:
             self.cli()
 
         else:
-            raise BioLibError('''
+            raise BioLibError("""
 Calling an app directly with app() is currently being reworked.
 To use the previous functionality, please call app.cli() instead. 
 Example: "app.cli('--help')"
-''')
+""")
 
     @staticmethod
     def _get_serialized_module_input(args=None, stdin=None, files=None) -> bytes:
@@ -142,9 +141,9 @@ Example: "app.cli('--help')"
                     args[idx] = Path(arg).name
 
                 # support --myarg=file.txt
-                elif os.path.isfile(arg.split("=")[-1]) or os.path.isdir(arg.split("=")[-1]):
-                    files.append(arg.split("=")[-1])
-                    args[idx] = arg.split("=")[0] + '=' + Path(arg.split("=")[-1]).name
+                elif os.path.isfile(arg.split('=')[-1]) or os.path.isdir(arg.split('=')[-1]):
+                    files.append(arg.split('=')[-1])
+                    args[idx] = arg.split('=')[0] + '=' + Path(arg.split('=')[-1]).name
                 else:
                     pass  # a normal string arg was given
             else:
@@ -154,7 +153,7 @@ Example: "app.cli('--help')"
                 elif isinstance(arg, io.BytesIO):
                     file_data = arg.getvalue()
                 else:
-                    raise Exception(f"Unexpected type of argument: {arg}")
+                    raise Exception(f'Unexpected type of argument: {arg}')
                 files_dict[f'/{tmp_filename}'] = file_data
                 args[idx] = tmp_filename
 
@@ -192,48 +191,10 @@ Example: "app.cli('--help')"
         )
         return module_input_serialized
 
-    def _start_in_cloud(
-            self,
-            module_input_serialized: bytes,
-            override_command: bool = False,
-            machine: Optional[str] = None,
-            experiment_id: Optional[str] = None,
-            result_prefix: Optional[str] = None,
-            timeout: Optional[int] = None,
-            notify: bool = False,
-    ) -> Job:
-        if len(module_input_serialized) < 500_000:
-            _job_dict = BiolibJobApi.create_job_with_data(
-                app_resource_name_prefix=parse_app_uri(self._app_uri)['resource_name_prefix'],
-                app_version_uuid=self._app_version['public_id'],
-                arguments_override_command=override_command,
-                experiment_uuid=experiment_id,
-                module_input_serialized=module_input_serialized,
-                notify=notify,
-                requested_machine=machine,
-                requested_timeout_seconds=timeout,
-                result_name_prefix=result_prefix,
-            )
-            return Job(cast(JobDict, _job_dict))
-
-        job_dict: CreatedJobDict = BiolibJobApi.create(
-            app_resource_name_prefix=parse_app_uri(self._app_uri)['resource_name_prefix'],
-            app_version_id=self._app_version['public_id'],
-            experiment_uuid=experiment_id,
-            machine=machine,
-            notify=notify,
-            override_command=override_command,
-            timeout=timeout,
-        )
-        JobStorage.upload_module_input(job=job_dict, module_input_serialized=module_input_serialized)
-        cloud_job = BiolibJobApi.create_cloud_job(job_id=job_dict['public_id'], result_name_prefix=result_prefix)
-        logger.debug(f"Cloud: Job created with id {cloud_job['public_id']}")
-        return Job(cast(JobDict, job_dict))
-
     def _run_locally(self, module_input_serialized: bytes) -> Job:
         job_dict = BiolibJobApi.create(
             app_version_id=self._app_version['public_id'],
-            app_resource_name_prefix=parse_app_uri(self._app_uri)['resource_name_prefix']
+            app_resource_name_prefix=parse_app_uri(self._app_uri)['resource_name_prefix'],
         )
         job = Job(job_dict)
 

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/biolib/biolib_binary_format/remote_endpoints.py

@@ -1,25 +1,27 @@
 from datetime import datetime, timedelta
-# from urllib.parse import urlparse, parse_qs
-
-from biolib.biolib_logging import logger
 
 from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
 from biolib.biolib_binary_format.utils import RemoteEndpoint
 
+# from urllib.parse import urlparse, parse_qs
+from biolib.biolib_logging import logger
+from biolib.typing_utils import Literal
+
 
-class RemoteJobStorageResultEndpoint(RemoteEndpoint):
-    def __init__(self, job_id: str, job_auth_token: str):
-        self._job_id = job_id
-        self._job_auth_token = job_auth_token
+class RemoteJobStorageEndpoint(RemoteEndpoint):
+    def __init__(self, job_uuid: str, job_auth_token: str, storage_type: Literal['input', 'output']):
         self._expires_at = None
+        self._job_auth_token = job_auth_token
+        self._job_uuid = job_uuid
         self._presigned_url = None
+        self._storage_type: Literal['input', 'output'] = storage_type
 
     def get_remote_url(self):
         if not self._presigned_url or datetime.utcnow() > self._expires_at:
             self._presigned_url = BiolibJobApi.get_job_storage_download_url(
                 job_auth_token=self._job_auth_token,
-                job_uuid=self._job_id,
-                storage_type='results'
+                job_uuid=self._job_uuid,
+                storage_type='results' if self._storage_type == 'output' else 'input',
             )
             self._expires_at = datetime.utcnow() + timedelta(minutes=8)
             # TODO: Use expires at from url
@@ -27,6 +29,6 @@ class RemoteJobStorageResultEndpoint(RemoteEndpoint):
             # query_params = parse_qs(parsed_url.query)
             # time_at_generation = datetime.datetime.strptime(query_params['X-Amz-Date'][0], '%Y%m%dT%H%M%SZ')
             # self._expires_at = time_at_generation + timedelta(seconds=int(query_params['X-Amz-Expires'][0]))
-            logger.debug(f'Job "{self._job_id}" fetched presigned URL with expiry at {self._expires_at.isoformat()}')
+            logger.debug(f'Job "{self._job_uuid}" fetched presigned URL with expiry at {self._expires_at.isoformat()}')
 
         return self._presigned_url

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/biolib/cli/auth.py

@@ -52,7 +52,7 @@ def whoami() -> None:
         email = user_dict['email']
         intrinsic_account = [account for account in user_dict['accounts'] if account['role'] == 'intrinsic'][0]
         display_name = intrinsic_account['display_name']
-        print(f'Name: {display_name}\nEmail: {email}')
+        print(f'Name: {display_name}\nEmail: {email}\nLogged into: {client.base_url}')
     else:
         print('Not logged in', file=sys.stderr)
         exit(1)

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/biolib/jobs/job.py

@@ -9,18 +9,22 @@ from urllib.parse import urlparse
 from biolib import api, utils
 from biolib._internal.http_client import HttpClient
 from biolib._internal.utils import open_browser_window_from_notebook
-from biolib.biolib_api_client import BiolibApiClient
+from biolib.biolib_api_client import BiolibApiClient, CreatedJobDict
+from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
 from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
 from biolib.biolib_binary_format import LazyLoadedFile, ModuleInput, ModuleInputDict, ModuleOutputV2
+from biolib.biolib_binary_format.remote_endpoints import RemoteJobStorageEndpoint
 from biolib.biolib_binary_format.stdout_and_stderr import StdoutAndStderr
 from biolib.biolib_errors import BioLibError, CloudJobFinishedError
 from biolib.biolib_logging import logger, logger_no_user_data
+from biolib.compute_node.job_worker.job_storage import JobStorage
 from biolib.compute_node.utils import SystemExceptionCodeMap, SystemExceptionCodes
 from biolib.jobs.job_result import JobResult
 from biolib.jobs.types import CloudJobDict, CloudJobStartedDict, JobDict
 from biolib.tables import BioLibTable
 from biolib.typing_utils import Dict, List, Optional, cast
 from biolib.utils import IS_RUNNING_IN_NOTEBOOK
+from biolib.utils.app_uri import parse_app_uri
 
 
 class Job:
@@ -198,6 +202,28 @@ class Job:
         except Exception as error:
             logger.error(f'Failed to cancel job {self._uuid} due to: {error}')
 
+    def recompute(self, app_uri: Optional[str] = None, machine: Optional[str] = None, blocking: bool = True) -> 'Job':
+        app_response = BiolibAppApi.get_by_uri(uri=app_uri or self._job_dict['app_uri'])
+
+        job_storage_input = RemoteJobStorageEndpoint(
+            job_auth_token=self._auth_token,
+            job_uuid=self._uuid,
+            storage_type='input',
+        )
+        http_response = HttpClient.request(url=job_storage_input.get_remote_url())
+        module_input_serialized = http_response.content
+
+        job = self._start_job_in_cloud(
+            app_uri=app_response['app_uri'],
+            app_version_uuid=app_response['app_version']['public_id'],
+            module_input_serialized=module_input_serialized,
+            machine=machine,
+        )
+        if blocking:
+            job.stream_logs()
+
+        return job
+
     def _get_cloud_job(self) -> CloudJobDict:
         self._refetch_job_dict(force_refetch=True)
         if self._job_dict['cloud_job'] is None:
@@ -377,3 +403,43 @@ class Job:
 
         self._job_dict = self._get_job_dict(self._uuid, self._auth_token)
         self._job_dict_last_fetched_at = datetime.utcnow()
+
+    @staticmethod
+    def _start_job_in_cloud(
+        app_uri: str,
+        app_version_uuid: str,
+        module_input_serialized: bytes,
+        override_command: bool = False,
+        machine: Optional[str] = None,
+        experiment_id: Optional[str] = None,
+        result_prefix: Optional[str] = None,
+        timeout: Optional[int] = None,
+        notify: bool = False,
+    ) -> 'Job':
+        if len(module_input_serialized) < 500_000:
+            _job_dict = BiolibJobApi.create_job_with_data(
+                app_resource_name_prefix=parse_app_uri(app_uri)['resource_name_prefix'],
+                app_version_uuid=app_version_uuid,
+                arguments_override_command=override_command,
+                experiment_uuid=experiment_id,
+                module_input_serialized=module_input_serialized,
+                notify=notify,
+                requested_machine=machine,
+                requested_timeout_seconds=timeout,
+                result_name_prefix=result_prefix,
+            )
+            return Job(cast(JobDict, _job_dict))
+
+        job_dict: CreatedJobDict = BiolibJobApi.create(
+            app_resource_name_prefix=parse_app_uri(app_uri)['resource_name_prefix'],
+            app_version_id=app_version_uuid,
+            experiment_uuid=experiment_id,
+            machine=machine,
+            notify=notify,
+            override_command=override_command,
+            timeout=timeout,
+        )
+        JobStorage.upload_module_input(job=job_dict, module_input_serialized=module_input_serialized)
+        cloud_job = BiolibJobApi.create_cloud_job(job_id=job_dict['public_id'], result_name_prefix=result_prefix)
+        logger.debug(f"Cloud: Job created with id {cloud_job['public_id']}")
+        return Job(cast(JobDict, job_dict))

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/biolib/jobs/job_result.py

@@ -3,7 +3,7 @@ from fnmatch import fnmatch
 from pathlib import Path
 
 from biolib.biolib_binary_format import ModuleOutputV2
-from biolib.biolib_binary_format.remote_endpoints import RemoteJobStorageResultEndpoint
+from biolib.biolib_binary_format.remote_endpoints import RemoteJobStorageEndpoint
 from biolib.biolib_binary_format.remote_stream_seeker import StreamSeeker
 from biolib.biolib_binary_format.utils import LazyLoadedFile, RemoteIndexableBuffer
 from biolib.biolib_errors import BioLibError
@@ -109,9 +109,10 @@ class JobResult:
 
     def _get_module_output(self) -> ModuleOutputV2:
         if self._module_output is None:
-            remote_job_storage_endpoint = RemoteJobStorageResultEndpoint(
-                job_id=self._job_uuid,
+            remote_job_storage_endpoint = RemoteJobStorageEndpoint(
                 job_auth_token=self._job_auth_token,
+                job_uuid=self._job_uuid,
+                storage_type='output',
             )
             buffer = RemoteIndexableBuffer(endpoint=remote_job_storage_endpoint)
             self._module_output = ModuleOutputV2(buffer)

{pybiolib-1.1.1974 → pybiolib-1.1.1979}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pybiolib"
-version = "1.1.1974"
+version = "1.1.1979"
 description = "BioLib Python Client"
 readme = "README.md"
 license = "MIT"