pybiolib 1.1.1974__py3-none-any.whl → 1.1.1984__py3-none-any.whl

biolib/_internal/fuse_mount/experiment_fuse_mount.py

@@ -3,12 +3,11 @@ import os
 import stat
 from datetime import datetime, timezone
 from time import time
-from typing import Iterable
 
 from biolib._internal.libs.fusepy import FUSE, FuseOSError, Operations
 from biolib.biolib_errors import BioLibError
 from biolib.jobs import Job
-from biolib.typing_utils import Dict, Optional, Tuple, TypedDict
+from biolib.typing_utils import Dict, List, Optional, Tuple, TypedDict
 
 
 class _AttributeDict(TypedDict):
@@ -27,7 +26,6 @@ class ExperimentFuseMount(Operations):
         self._experiment = experiment
         self._job_names_map: Optional[Dict[str, Job]] = None
         self._jobs_last_fetched_at: float = 0.0
-        self._root_path: str = '/'
         self._mounted_at_epoch_seconds: int = int(time())
 
     @staticmethod
@@ -41,80 +39,77 @@ class ExperimentFuseMount(Operations):
         )
 
     def getattr(self, path: str, fh=None) -> _AttributeDict:
-        full_path = self._full_path(path)
-        if full_path == '/':
-            # return folder dir
-            return self._get_folder_attr(timestamp_epoch_seconds=self._mounted_at_epoch_seconds)
-
-        job_name, job_path = self._parse_path(path)
-        job = self._get_job_names_map().get(job_name)
-        if not job:
-            # job not found
-            raise FuseOSError(errno.ENOENT)
+        if path == '/':
+            return self._get_directory_attributes(timestamp_epoch_seconds=self._mounted_at_epoch_seconds)
 
+        job, path_in_job = self._parse_path(path)
         job_finished_at_epoch_seconds: int = int(
             datetime.fromisoformat(job.to_dict()['finished_at'].rstrip('Z')).replace(tzinfo=timezone.utc).timestamp()
         )
-        if not job_path or job_path == '/':
-            # job root path
-            return self._get_folder_attr(timestamp_epoch_seconds=job_finished_at_epoch_seconds)
+
+        if path_in_job == '/':
+            return self._get_directory_attributes(timestamp_epoch_seconds=job_finished_at_epoch_seconds)
 
         try:
-            file = job.get_output_file(job_path)
+            file = job.get_output_file(path_in_job)
+            return self._get_file_attributes(
+                timestamp_epoch_seconds=job_finished_at_epoch_seconds,
+                size_in_bytes=file.length,
+            )
         except BioLibError:
             # file not found
-            raise FuseOSError(errno.ENOENT) from None
+            pass
 
-        return _AttributeDict(
-            st_atime=job_finished_at_epoch_seconds,
-            st_ctime=job_finished_at_epoch_seconds,
-            st_gid=os.getgid(),
-            st_mode=stat.S_IFREG | 0o444,  # Regular file with read permissions for owner, group, and others.
-            st_mtime=job_finished_at_epoch_seconds,
-            st_nlink=1,
-            st_size=file.length,
-            st_uid=os.getuid(),
-        )
+        file_paths_in_job = [file.path for file in job.list_output_files()]
+
+        for file_path_in_job in file_paths_in_job:
+            if file_path_in_job.startswith(path_in_job):
+                return self._get_directory_attributes(timestamp_epoch_seconds=job_finished_at_epoch_seconds)
 
-    def readdir(self, path: str, fh: int) -> Iterable[str]:
+        raise FuseOSError(errno.ENOENT) from None  # No such file or directory
+
+    def readdir(self, path: str, fh: int) -> List[str]:
         directory_entries = ['.', '..']
+
         if path == '/':
-            for name in self._get_job_names_map(refresh_jobs=True):
-                directory_entries.append(name)
+            directory_entries.extend(self._get_job_names_map(refresh_jobs=True).keys())
         else:
-            job_name, job_path = self._parse_path(path)
-            job = self._get_job_names_map()[job_name]
-            in_target_directory = set(
-                [k.path.split('/')[1] for k in job.list_output_files() if k.path.startswith(job_path)]
+            job, path_in_job = self._parse_path(path)
+            dir_path_in_job = '/' if path_in_job == '/' else path_in_job + '/'
+            depth = dir_path_in_job.count('/')
+            directory_entries.extend(
+                set(
+                    [
+                        file.path.split('/')[depth]
+                        for file in job.list_output_files()
+                        if file.path.startswith(dir_path_in_job)
+                    ]
+                )
             )
 
-            for key in in_target_directory:
-                directory_entries.append(key)
-
-        yield from directory_entries
+        return directory_entries
 
     def open(self, path: str, flags: int) -> int:
-        job_name, job_path = self._parse_path(path)
-        job = self._get_job_names_map()[job_name]
+        job, path_in_job = self._parse_path(path)
         try:
-            job.get_output_file(job_path)
-            return 0  # return dummy file handle
+            job.get_output_file(path_in_job)
         except BioLibError:
             # file not found
             raise FuseOSError(errno.ENOENT) from None
 
+        return 0  # return dummy file handle
+
     def read(self, path: str, size: int, offset: int, fh: int) -> bytes:
-        job_name, job_path = self._parse_path(path)
-        job = self._get_job_names_map()[job_name]
+        job, path_in_job = self._parse_path(path)
         try:
-            file = job.get_output_file(job_path)
+            file = job.get_output_file(path_in_job)
         except BioLibError:
-            # file not found
-            raise FuseOSError(errno.ENOENT) from None
+            raise FuseOSError(errno.ENOENT) from None  # No such file or directory
 
         return file.get_data(start=offset, length=size)
 
-    def _get_folder_attr(self, timestamp_epoch_seconds: int) -> _AttributeDict:
+    @staticmethod
+    def _get_directory_attributes(timestamp_epoch_seconds: int) -> _AttributeDict:
         return _AttributeDict(
             st_atime=timestamp_epoch_seconds,
             st_ctime=timestamp_epoch_seconds,
@@ -126,6 +121,19 @@ class ExperimentFuseMount(Operations):
             st_uid=os.getuid(),
         )
 
+    @staticmethod
+    def _get_file_attributes(timestamp_epoch_seconds: int, size_in_bytes: int) -> _AttributeDict:
+        return _AttributeDict(
+            st_atime=timestamp_epoch_seconds,
+            st_ctime=timestamp_epoch_seconds,
+            st_gid=os.getgid(),
+            st_mode=stat.S_IFREG | 0o444,  # Regular file with read permissions for owner, group, and others.
+            st_mtime=timestamp_epoch_seconds,
+            st_nlink=1,
+            st_size=size_in_bytes,
+            st_uid=os.getuid(),
+        )
+
     def _get_job_names_map(self, refresh_jobs=False) -> Dict[str, Job]:
         current_time = time()
         if not self._job_names_map or (current_time - self._jobs_last_fetched_at > 1 and refresh_jobs):
@@ -134,18 +142,15 @@ class ExperimentFuseMount(Operations):
 
         return self._job_names_map
 
-    def _full_path(self, partial: str) -> str:
-        if partial.startswith('/'):
-            partial = partial[1:]
-
-        return os.path.join(self._root_path, partial)
+    def _parse_path(self, path: str) -> Tuple[Job, str]:
+        path_splitted = path.split('/')
+        job_name = path_splitted[1]
+        path_in_job = '/' + '/'.join(path_splitted[2:])
+        job = self._get_job_names_map().get(job_name)
+        if not job:
+            raise FuseOSError(errno.ENOENT)  # No such file or directory
 
-    def _parse_path(self, path: str) -> Tuple[str, str]:
-        full_path = self._full_path(path)
-        full_path_splitted = full_path.split('/')
-        job_name = full_path_splitted[1]
-        job_path = '/'.join(full_path_splitted[2:])
-        return job_name, job_path
+        return job, path_in_job
 
     # ----------------------------------- File system methods not implemented below -----------------------------------
 

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)
 

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

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)

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))

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.dist-info → pybiolib-1.1.1984.dist-info}/METADATA

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

{pybiolib-1.1.1974.dist-info → pybiolib-1.1.1984.dist-info}/RECORD

@@ -6,7 +6,7 @@ biolib/_internal/data_record/__init__.py,sha256=1Bk303i3rFet9veS56fIsrBYtT5X3n9v
 biolib/_internal/data_record/data_record.py,sha256=ctijrrZ-LfUxtwzS8PEVa1VBuBLVWEhmo2yHcEDkC0A,7178
 biolib/_internal/data_record/remote_storage_endpoint.py,sha256=LPq8Lr5FhKF9_o5K-bUdT7TeLe5XFUD0AAeTkNEVZug,1133
 biolib/_internal/fuse_mount/__init__.py,sha256=B_tM6RM2dBw-vbpoHJC4X3tOAaN1H2RDvqYJOw3xFwg,55
-biolib/_internal/fuse_mount/experiment_fuse_mount.py,sha256=tRkgPncbf9Nl22adcjBTJuFfiYMkayYJSJ--WQrB-Ps,6629
+biolib/_internal/fuse_mount/experiment_fuse_mount.py,sha256=DcR2NyUyZYgpsaKM1WBJZChAaD2vvt_vvZCXj-P2UTs,6878
 biolib/_internal/http_client.py,sha256=DdooXei93JKGYGV4aQmzue_oFzvHkozg2UCxgk9dfDM,5081
 biolib/_internal/libs/__init__.py,sha256=Jdf4tNPqe_oIIf6zYml6TiqhL_02Vyqwge6IELrAFhw,98
 biolib/_internal/libs/fusepy/__init__.py,sha256=AWDzNFS-XV_5yKb0Qx7kggIhPzq1nj_BZS5y2Nso08k,41944
@@ -16,7 +16,7 @@ biolib/_internal/utils/__init__.py,sha256=p5vsIFyu-zYqBgdSMfwW9NC_jk7rXvvCbV4Bzd
 biolib/api/__init__.py,sha256=iIO8ZRdn7YDhY5cR47-Wo1YsNOK8H6RN6jn8yor5WJI,137
 biolib/api/client.py,sha256=MtDkH2Amr2Fko-bCR5DdookJu0yZ1q-6K_PPg4KK_Ek,2941
 biolib/app/__init__.py,sha256=cdPtcfb_U-bxb9iSL4fCEq2rpD9OjkyY4W-Zw60B0LI,37
-biolib/app/app.py,sha256=r63gDoH1s8uQOGITmiKOVIrYDYdMrB5nwXHNRt2Da2M,10197
+biolib/app/app.py,sha256=8AvPYL1W2wxQ7t7BB2KeVU2WPrm3UL6vVuHPGs8g9L0,8388
 biolib/app/search_apps.py,sha256=K4a41f5XIWth2BWI7OffASgIsD0ko8elCax8YL2igaY,1470
 biolib/biolib_api_client/__init__.py,sha256=E5EMa19wJoblwSdQPYrxc_BtIeRsAuO0L_jQweWw-Yk,182
 biolib/biolib_api_client/api_client.py,sha256=J03jRVvod1bgwwAZ3BZVKlUSJi43-ev2DUB0j63GZpc,7189
@@ -33,7 +33,7 @@ biolib/biolib_binary_format/base_bbf_package.py,sha256=vxRV4iKy0dXeDOlFWnMFI0hGn
 biolib/biolib_binary_format/file_in_container.py,sha256=j1eEPRxf_ew8I6G8sDiiZZxn4Wx1ppagfM9K8zTDG4U,3591
 biolib/biolib_binary_format/module_input.py,sha256=led2QhHeec_ymBPw5uEn3_3vJKI-1T8zrFQGqwEWLMY,2788
 biolib/biolib_binary_format/module_output_v2.py,sha256=J5ZO5gCSeudpE12EVDrjYrNTS2DwgszY-SVXT7Qjuyg,5913
-biolib/biolib_binary_format/remote_endpoints.py,sha256=aeW479pm4YQPF4hXYJoKfBq_auE1QW6r066HTcYRwOY,1447
+biolib/biolib_binary_format/remote_endpoints.py,sha256=V48mwOj3eAQAKp-8DjtWUdEKUyC0WKc1pEiKTmtjrJY,1651
 biolib/biolib_binary_format/remote_stream_seeker.py,sha256=uyi6kJBU1C1DWfiuR0kRUQIY7nalG7ocgwgngd3Ul4U,1999
 biolib/biolib_binary_format/saved_job.py,sha256=nFHVFRNTNcAFGODLSiBntCtMk55QKwreUq6qLX80dI4,1125
 biolib/biolib_binary_format/stdout_and_stderr.py,sha256=WfUUJFFCBrtfXjuWIaRPiWCpuBLxfko68oxoTKhrwx8,1023
@@ -45,7 +45,7 @@ biolib/biolib_download_container.py,sha256=8TmBV8iv3bCvkNlHa1SSsc4zl0wX_eaxhfnW5
 biolib/biolib_errors.py,sha256=5m4lK2l39DafpoXBImEBD4EPH3ayXBX0JgtPzmGClow,689
 biolib/biolib_logging.py,sha256=J3E5H_LL5k6ZUim2C8gqN7E6lCBZMTpO4tnMpOPwG9U,2854
 biolib/cli/__init__.py,sha256=0v3c_J-U0k46c5ZWeQjLG_kTaKDJm81LBxQpDO2B_aI,1286
-biolib/cli/auth.py,sha256=wp-JQRzDgiEbxeUTxwlHfugk-9u6PiOtZiHl9brAgcA,2050
+biolib/cli/auth.py,sha256=rpWGmXs6Fz6CGrO9K8ibPRszOdXG78Vig_boKaVCD9A,2082
 biolib/cli/data_record.py,sha256=piN3QUbRAkMi4wpayghN4unFfuiNE5VCjI1gag4d8qg,1725
 biolib/cli/download_container.py,sha256=HIZVHOPmslGE5M2Dsp9r2cCkAEJx__vcsDz5Wt5LRos,483
 biolib/cli/init.py,sha256=wQOfii_au-d30Hp7DdH-WVw-WVraKvA_zY4za1w7DE8,821
@@ -89,8 +89,8 @@ biolib/experiments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 biolib/experiments/experiment.py,sha256=kUQsH9AGAckPKT_nzaRuTh8Mb2pVUpxnuX9IstRTOEo,6351
 biolib/experiments/types.py,sha256=n9GxdFA7cLMfHvLLqLmZzX31ELeSSkMXFoEEdFsdWGY,171
 biolib/jobs/__init__.py,sha256=aIb2H2DHjQbM2Bs-dysFijhwFcL58Blp0Co0gimED3w,32
-biolib/jobs/job.py,sha256=-H83m5BJs0l9Pe_lsExlcqH5gAHOVREeQBZs6umWdYc,16178
-biolib/jobs/job_result.py,sha256=bJm0q7L_11ekOJBiC6jIaeYo_zxDJKSB0TGsLI30BBo,4896
+biolib/jobs/job.py,sha256=aWKnf_2pYdr76gh3hxPiVs2iuXlpwZkKPTK81Pz4G2U,19072
+biolib/jobs/job_result.py,sha256=UGxE9MNLtwJiWmhw2UNjOQW7EZi7B-e2lL0PXYvsXeA,4925
 biolib/jobs/types.py,sha256=qhadtH2KDC2WUOOqPiwke0YgtQY4FtuB71Stekq1k48,970
 biolib/lfs/__init__.py,sha256=Qv8vdYeK43JecT4SsE93ZYE2VmNiZENdNpW8P9-omxs,115
 biolib/lfs/cache.py,sha256=pQS2np21rdJ6I3DpoOutnzPHpLOZgUIS8TMltUJk_k4,2226
@@ -109,8 +109,8 @@ biolib/utils/cache_state.py,sha256=u256F37QSRIVwqKlbnCyzAX4EMI-kl6Dwu6qwj-Qmag,3
 biolib/utils/multipart_uploader.py,sha256=XvGP1I8tQuKhAH-QugPRoEsCi9qvbRk-DVBs5PNwwJo,8452
 biolib/utils/seq_util.py,sha256=jC5WhH63FTD7SLFJbxQGA2hOt9NTwq9zHl_BEec1Z0c,4907
 biolib/utils/zip/remote_zip.py,sha256=0wErYlxir5921agfFeV1xVjf29l9VNgGQvNlWOlj2Yc,23232
-pybiolib-1.1.1974.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
-pybiolib-1.1.1974.dist-info/METADATA,sha256=pTLqiAvKtqfjL4SzRbwKtNUCKdpePX8CJzlm2S4naFI,1508
-pybiolib-1.1.1974.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pybiolib-1.1.1974.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
-pybiolib-1.1.1974.dist-info/RECORD,,
+pybiolib-1.1.1984.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+pybiolib-1.1.1984.dist-info/METADATA,sha256=PO0Sif5QkYXg1P20p7306bX-CXn6-Mpee7epEsP-1Fo,1508
+pybiolib-1.1.1984.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pybiolib-1.1.1984.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
+pybiolib-1.1.1984.dist-info/RECORD,,