pybiolib 1.2.567__py3-none-any.whl → 1.2.582__py3-none-any.whl

biolib/_session/session.py

@@ -0,0 +1,39 @@
+from biolib import utils
+from biolib._internal.types import Optional
+from biolib.api.client import ApiClient, ApiClientInitDict
+from biolib.app import BioLibApp
+
+
+class Session:
+    def __init__(self, _init_dict: ApiClientInitDict) -> None:
+        self._api = ApiClient(_init_dict=_init_dict)
+
+    @staticmethod
+    def get_session(refresh_token: str, base_url: Optional[str] = None) -> 'Session':
+        return Session(
+            _init_dict=ApiClientInitDict(
+                refresh_token=refresh_token,
+                base_url=base_url or utils.load_base_url_from_env(),
+            )
+        )
+
+    def load(self, uri: str) -> BioLibApp:
+        r"""Load a BioLib application by its URI or website URL.
+
+        Args:
+            uri (str): The URI or website URL of the application to load. Can be either:
+                - App URI (e.g., 'biolib/myapp:1.0.0')
+                - Website URL (e.g., 'https://biolib.com/biolib/myapp/')
+
+        Returns:
+            BioLibApp: The loaded application object
+
+        Example::
+
+            >>> # Load by URI
+            >>> app = biolib.load('biolib/myapp:1.0.0')
+            >>> # Load by website URL
+            >>> app = biolib.load('https://biolib.com/biolib/myapp/')
+            >>> result = app.cli('--help')
+        """
+        return BioLibApp(uri=uri, _api_client=self._api)

biolib/api/client.py

@@ -1,10 +1,17 @@
+import base64
+import binascii
+import json
+from datetime import datetime, timezone
+from json.decoder import JSONDecodeError
 from urllib.parse import urlencode, urljoin
 
 import importlib_metadata
 
 from biolib._internal.http_client import HttpClient, HttpResponse
+from biolib._internal.types.typing import Any, Dict, Optional, TypedDict, Union, cast
 from biolib.biolib_api_client import BiolibApiClient as DeprecatedApiClient
-from biolib.typing_utils import Dict, Optional, Union, cast
+from biolib.biolib_errors import BioLibError
+from biolib.biolib_logging import logger
 
 OptionalHeaders = Union[
     Optional[Dict[str, str]],
@@ -20,9 +27,23 @@ def _get_biolib_package_version() -> str:
         return '0.0.0'
 
 
+class ApiClientInitDict(TypedDict):
+    refresh_token: str
+    base_url: str
+
+
+class JwtDecodeError(Exception):
+    pass
+
+
 class ApiClient(HttpClient):
     _biolib_package_version: str = _get_biolib_package_version()
 
+    def __init__(self, _init_dict: Optional[ApiClientInitDict] = None) -> None:
+        self._access_token: Optional[str] = None
+        self._refresh_token: Optional[str] = _init_dict['refresh_token'] if _init_dict else None
+        self._base_url: Optional[str] = _init_dict['base_url'] if _init_dict else None
+
     def get(
         self,
         path: str,
@@ -83,36 +104,104 @@ class ApiClient(HttpClient):
             url=self._get_absolute_url(path=path, query_params=None),
         )
 
-    @staticmethod
-    def _get_headers(opt_headers: OptionalHeaders, authenticate: bool) -> Dict[str, str]:
+    def _get_headers(self, opt_headers: OptionalHeaders, authenticate: bool) -> Dict[str, str]:
         # Only keep header keys with a value
         headers: Dict[str, str] = {key: value for key, value in (opt_headers or {}).items() if value}
 
         if authenticate:
-            deprecated_api_client = DeprecatedApiClient.get()
-            if deprecated_api_client.is_signed_in:
-                deprecated_api_client.refresh_access_token()
-
-            if deprecated_api_client.resource_deploy_key:
-                headers['Authorization'] = f'Token {deprecated_api_client.resource_deploy_key}'
+            if self._refresh_token:
+                headers['Authorization'] = f'Bearer {self._get_access_token()}'
             else:
-                # Adding access_token outside is_signed_in check as job_worker.py currently sets access_token
-                # without setting refresh_token
-                access_token = deprecated_api_client.access_token
-                if access_token:
-                    headers['Authorization'] = f'Bearer {access_token}'
+                # TODO: Remove this block when deprecated api client is removed
+                deprecated_api_client = DeprecatedApiClient.get()
+                if deprecated_api_client.is_signed_in:
+                    deprecated_api_client.refresh_access_token()
+
+                if deprecated_api_client.resource_deploy_key:
+                    headers['Authorization'] = f'Token {deprecated_api_client.resource_deploy_key}'
+                else:
+                    # Adding access_token outside is_signed_in check as job_worker.py currently sets access_token
+                    # without setting refresh_token
+                    access_token = deprecated_api_client.access_token
+                    if access_token:
+                        headers['Authorization'] = f'Bearer {access_token}'
 
         headers['client-type'] = 'biolib-python'
         headers['client-version'] = ApiClient._biolib_package_version
 
         return headers
 
-    @staticmethod
-    def _get_absolute_url(path: str, query_params: Optional[Dict[str, Union[str, int]]]) -> str:
+    def _get_absolute_url(self, path: str, query_params: Optional[Dict[str, Union[str, int]]]) -> str:
         deprecated_api_client = DeprecatedApiClient.get()
-        base_api_url = urljoin(deprecated_api_client.base_url, '/api/')
+        base_url = self._base_url or deprecated_api_client.base_url
+        base_api_url = urljoin(base_url, '/api/')
         url = urljoin(base_api_url, path.strip('/') + '/')
         if query_params:
             url = url + '?' + urlencode(query_params)
 
         return url
+
+    def _get_access_token(self) -> str:
+        if self._access_token:
+            decoded_token = self._decode_jwt_without_checking_signature(self._access_token)
+            if datetime.now(tz=timezone.utc).timestamp() < decoded_token['payload']['exp'] - 60:  # 60 second buffer
+                # Token has not expired yet
+                return self._access_token
+
+        # TODO: Implement nicer error handling
+        try:
+            response = HttpClient.request(
+                method='POST',
+                url=f'{self._base_url}/api/user/token/refresh/',
+                data={'refresh': self._refresh_token},
+            )
+        except Exception as exception:
+            logger.error('Sign in with refresh token failed')
+            raise exception
+
+        try:
+            response_dict = response.json()
+        except JSONDecodeError as error:
+            logger.error('Could not decode response from server as JSON:')
+            raise BioLibError(response.text) from error
+
+        self._access_token = cast(str, response_dict['access'])
+        return self._access_token
+
+    @staticmethod
+    def _decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
+        jwt_bytes = jwt.encode('utf-8')
+
+        try:
+            signing_input, _ = jwt_bytes.rsplit(b'.', 1)
+            header_segment, payload_segment = signing_input.split(b'.', 1)
+        except ValueError as error:
+            raise JwtDecodeError('Not enough segments') from error
+
+        try:
+            header_data = base64.urlsafe_b64decode(header_segment)
+        except (TypeError, binascii.Error) as error:
+            raise JwtDecodeError('Invalid header padding') from error
+
+        try:
+            header = json.loads(header_data)
+        except ValueError as error:
+            raise JwtDecodeError(f'Invalid header string: {error}') from error
+
+        if not isinstance(header, dict):
+            raise JwtDecodeError('Invalid header string: must be a json object')
+
+        try:
+            payload_data = base64.urlsafe_b64decode(payload_segment)
+        except (TypeError, binascii.Error) as error:
+            raise JwtDecodeError('Invalid payload padding') from error
+
+        try:
+            payload = json.loads(payload_data)
+        except ValueError as error:
+            raise JwtDecodeError(f'Invalid payload string: {error}') from error
+
+        if not isinstance(header, dict):
+            raise JwtDecodeError('Invalid payload string: must be a json object')
+
+        return dict(header=header, payload=payload)

biolib/app/app.py

@@ -6,6 +6,7 @@ import string
 from pathlib import Path
 
 from biolib import utils
+from biolib.api.client import ApiClient
 from biolib.biolib_api_client import JobState
 from biolib.biolib_api_client.app_types import App, AppVersion
 from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
@@ -16,13 +17,15 @@ 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, Dict
+from biolib.typing_utils import Dict, Optional
 from biolib.utils.app_uri import parse_app_uri
 
 
 class BioLibApp:
-    def __init__(self, uri: str):
-        app_response = BiolibAppApi.get_by_uri(uri)
+    def __init__(self, uri: str, _api_client: Optional[ApiClient] = None):
+        self._api_client: Optional[ApiClient] = _api_client
+
+        app_response = BiolibAppApi.get_by_uri(uri=uri, api_client=self._api_client)
         self._app: App = app_response['app']
         self._app_uri = app_response['app_uri']
         self._app_version: AppVersion = app_response['app_version']
@@ -98,7 +101,9 @@ class BioLibApp:
             timeout=timeout,
             requested_machine_count=machine_count,
             temporary_client_secrets=temporary_client_secrets,
+            api_client=self._api_client,
         )
+        logger.info(f'View the result in your browser at: {utils.BIOLIB_BASE_URL}/results/{job.id}/')
         if blocking:
             # TODO: Deprecate utils.STREAM_STDOUT and always stream logs by simply calling job.stream_logs()
             if utils.IS_RUNNING_IN_NOTEBOOK:

biolib/biolib_api_client/biolib_app_api.py

@@ -8,6 +8,7 @@ import urllib.parse
 import biolib.api
 from biolib import biolib_errors
 from biolib._internal.http_client import HttpError
+from biolib.api.client import ApiClient
 from biolib.biolib_api_client import AppGetResponse
 from biolib.biolib_logging import logger
 from biolib.typing_utils import Optional
@@ -84,10 +85,11 @@ def _get_app_uri_from_str(input_str: str) -> str:
 
 class BiolibAppApi:
     @staticmethod
-    def get_by_uri(uri: str) -> AppGetResponse:
+    def get_by_uri(uri: str, api_client: Optional[ApiClient] = None) -> AppGetResponse:
         uri = _get_app_uri_from_str(uri)
+        api = api_client or biolib.api.client
         try:
-            response = biolib.api.client.get(path='/app/', params={'uri': uri})
+            response = api.get(path='/app/', params={'uri': uri})
             app_response: AppGetResponse = response.json()
             return app_response
 

biolib/biolib_api_client/biolib_job_api.py

@@ -5,6 +5,7 @@ import biolib.api
 
 from biolib import utils
 from biolib._internal.http_client import HttpError
+from biolib.api.client import ApiClient
 from biolib.biolib_api_client import CloudJob, JobState
 from biolib.biolib_errors import JobResultPermissionError, JobResultError, JobResultNotFound, StorageDownloadFailed
 from biolib.biolib_logging import logger
@@ -35,19 +36,19 @@ def _get_user_info() -> Optional[str]:
 
 
 class BiolibJobApi:
-
     @staticmethod
     def create(
-            app_version_id,
-            app_resource_name_prefix=None,
-            override_command=False,
-            caller_job=None,
-            machine='',
-            experiment_uuid: Optional[str] = None,
-            timeout: Optional[int] = None,
-            notify: bool = False,
-            requested_machine_count: Optional[int] = None,
-            temporary_client_secrets: Optional[Dict[str, str]] = None,
+        app_version_id,
+        app_resource_name_prefix=None,
+        override_command=False,
+        caller_job=None,
+        machine='',
+        experiment_uuid: Optional[str] = None,
+        timeout: Optional[int] = None,
+        notify: bool = False,
+        requested_machine_count: Optional[int] = None,
+        temporary_client_secrets: Optional[Dict[str, str]] = None,
+        api_client: Optional[ApiClient] = None,
     ):
         data = {
             'app_version_id': app_version_id,
@@ -58,22 +59,16 @@ class BiolibJobApi:
         }
 
         if app_resource_name_prefix:
-            data.update({
-                'app_resource_name_prefix': app_resource_name_prefix
-            })
+            data.update({'app_resource_name_prefix': app_resource_name_prefix})
 
         if override_command:
-            data.update({
-                'arguments_override_command': override_command
-            })
+            data.update({'arguments_override_command': override_command})
 
         if caller_job:
             data['caller_job'] = caller_job
 
         if machine:
-            data.update({
-                'requested_machine': machine
-            })
+            data.update({'requested_machine': machine})
 
         if requested_machine_count:
             data.update({'requested_machine_count': requested_machine_count})
@@ -87,7 +82,8 @@ class BiolibJobApi:
         if temporary_client_secrets:
             data['temporary_client_secrets'] = temporary_client_secrets
 
-        response = biolib.api.client.post(path='/jobs/', data=data)
+        api = api_client or biolib.api.client
+        response = api.post(path='/jobs/', data=data)
 
         return response.json()
 
@@ -99,20 +95,25 @@ class BiolibJobApi:
             logger.error(f'Failed to update job "{job_uuid}" to state "{state.value}" due to {error}')
 
     @staticmethod
-    def create_cloud_job(job_id: str, result_name_prefix: Optional[str]) -> CloudJob:
+    def create_cloud_job(
+        job_id: str,
+        result_name_prefix: Optional[str],
+        api_client: Optional[ApiClient] = None,
+    ) -> CloudJob:
         data = {'job_id': job_id}
         if result_name_prefix:
             data['result_name_prefix'] = result_name_prefix
 
-        response = biolib.api.client.post(path='/jobs/cloud/', data=data)
+        api = api_client or biolib.api.client
+        response = api.post(path='/jobs/cloud/', data=data)
         cloud_job: CloudJob = response.json()
         return cloud_job
 
     @staticmethod
     def get_job_storage_download_url(
-            job_uuid: str,
-            job_auth_token: str,
-            storage_type: Literal['input', 'results'],
+        job_uuid: str,
+        job_auth_token: str,
+        storage_type: Literal['input', 'results'],
     ) -> str:
         try:
             response = biolib.api.client.get(
@@ -154,19 +155,21 @@ class BiolibJobApi:
 
     @staticmethod
     def create_job_with_data(
-            app_version_uuid: str,
-            app_resource_name_prefix: Optional[str],
-            module_input_serialized: bytes,
-            arguments_override_command: bool,
-            experiment_uuid: Optional[str],
-            requested_machine: Optional[str],
-            result_name_prefix: Optional[str],
-            caller_job_uuid: Optional[str] = None,
-            requested_timeout_seconds: Optional[int] = None,
-            notify: bool = False,
-            requested_machine_count: Optional[int] = None,
+        app_version_uuid: str,
+        app_resource_name_prefix: Optional[str],
+        module_input_serialized: bytes,
+        arguments_override_command: bool,
+        experiment_uuid: Optional[str],
+        requested_machine: Optional[str],
+        result_name_prefix: Optional[str],
+        caller_job_uuid: Optional[str] = None,
+        requested_timeout_seconds: Optional[int] = None,
+        notify: bool = False,
+        requested_machine_count: Optional[int] = None,
+        api_client: Optional[ApiClient] = None,
     ) -> Dict:
-        job_dict: Dict = biolib.api.client.post(
+        api = api_client or biolib.api.client
+        job_dict: Dict = api.post(
             path='/jobs/create_job_with_data/',
             data=module_input_serialized,
             headers={
@@ -184,6 +187,6 @@ class BiolibJobApi:
                 'result-name-prefix': result_name_prefix,
                 'requested-timeout-seconds': str(requested_timeout_seconds) if requested_timeout_seconds else None,
                 'notify': 'true' if notify else 'false',
-            }
+            },
         ).json()
         return job_dict

biolib/jobs/job.py

@@ -6,9 +6,11 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from urllib.parse import urlparse
 
-from biolib import api, utils
+import biolib.api.client
+from biolib import utils
 from biolib._internal.http_client import HttpClient
 from biolib._internal.utils import open_browser_window_from_notebook
+from biolib.api.client import ApiClient
 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
@@ -39,7 +41,9 @@ class Job:
         }
     )
 
-    def __init__(self, job_dict: JobDict):
+    def __init__(self, job_dict: JobDict, _api_client: Optional[ApiClient] = None):
+        self._api_client: Optional[ApiClient] = _api_client
+
         self._uuid: str = job_dict['uuid']
         self._auth_token: str = job_dict['auth_token']
 
@@ -208,7 +212,7 @@ class Job:
 
     def cancel(self) -> None:
         try:
-            api.client.patch(
+            biolib.api.client.patch(
                 path=f'/jobs/{self._uuid}/',
                 headers={'Job-Auth-Token': self._auth_token} if self._auth_token else None,
                 data={'state': 'cancelled'},
@@ -219,7 +223,7 @@ class Job:
 
     def rename(self, name: str) -> None:
         try:
-            api.client.patch(
+            biolib.api.client.patch(
                 path=f'/jobs/{self._uuid}/main_result/',
                 headers={'Job-Auth-Token': self._auth_token} if self._auth_token else None,
                 data={'result_name_prefix': name},
@@ -325,20 +329,21 @@ class Job:
             params['state'] = status
 
         api_path = '/jobs/'
-        response = api.client.get(api_path, params=params).json()
+        response = biolib.api.client.get(api_path, params=params).json()
         jobs = [job_dict for job_dict in response['results']]
 
         for page_number in range(2, response['page_count'] + 1):
             if len(jobs) >= count:
                 break
-            page_response = api.client.get(path=api_path, params=dict(**params, page=page_number)).json()
+            page_response = biolib.api.client.get(path=api_path, params=dict(**params, page=page_number)).json()
             jobs.extend([job_dict for job_dict in page_response['results']])
 
         return jobs[:count]
 
     @staticmethod
-    def _get_job_dict(uuid: str, auth_token: Optional[str] = None) -> JobDict:
-        job_dict: JobDict = api.client.get(
+    def _get_job_dict(uuid: str, auth_token: Optional[str] = None, api_client: Optional[ApiClient] = None) -> JobDict:
+        api = api_client or biolib.api.client
+        job_dict: JobDict = api.get(
             path=f'/jobs/{uuid}/',
             headers={'Job-Auth-Token': auth_token} if auth_token else None,
         ).json()
@@ -506,6 +511,7 @@ class Job:
         notify: bool = False,
         requested_machine_count: Optional[int] = None,
         temporary_client_secrets: Optional[Dict[str, str]] = None,
+        api_client: Optional[ApiClient] = None,
     ) -> 'Job':
         if len(module_input_serialized) < 500_000 and temporary_client_secrets is None:
             _job_dict = BiolibJobApi.create_job_with_data(
@@ -519,6 +525,7 @@ class Job:
                 requested_timeout_seconds=timeout,
                 result_name_prefix=result_prefix,
                 requested_machine_count=requested_machine_count,
+                api_client=api_client,
             )
             return Job(cast(JobDict, _job_dict))
 
@@ -532,8 +539,9 @@ class Job:
             timeout=timeout,
             requested_machine_count=requested_machine_count,
             temporary_client_secrets=temporary_client_secrets,
+            api_client=api_client,
         )
         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))
+        return Job(cast(JobDict, job_dict), _api_client=api_client)

biolib/sdk/__init__.py

@@ -5,12 +5,17 @@ from biolib._data_record.data_record import DataRecord as _DataRecord
 from biolib._internal.push_application import push_application as _push_application
 from biolib._internal.push_application import set_app_version_as_active as _set_app_version_as_active
 from biolib._runtime.runtime import Runtime as _Runtime
+from biolib._session.session import Session as _Session
 from biolib.app import BioLibApp as _BioLibApp
 
 # Classes to expose as public API
 Runtime = _Runtime
 
 
+def get_session(refresh_token: str, base_url: Optional[str] = None) -> _Session:
+    return _Session.get_session(refresh_token=refresh_token, base_url=base_url)
+
+
 def push_app_version(uri: str, path: str) -> _BioLibApp:
     push_data = _push_application(
         app_uri=uri,

{pybiolib-1.2.567.dist-info → pybiolib-1.2.582.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pybiolib
-Version: 1.2.567
+Version: 1.2.582
 Summary: BioLib Python Client
 License: MIT
 Keywords: biolib

{pybiolib-1.2.567.dist-info → pybiolib-1.2.582.dist-info}/RECORD

@@ -26,17 +26,18 @@ biolib/_internal/types/typing.py,sha256=qrsk8hHcGEbDpU1QQFzHAKnhQxkMe7uJ6pxHeAnf
 biolib/_internal/utils/__init__.py,sha256=p5vsIFyu-zYqBgdSMfwW9NC_jk7rXvvCbV4Bzd3As7c,630
 biolib/_internal/utils/multinode.py,sha256=-J3PEAK3NaOwCn--5T7vWHkA3yu5w9QhmuhkQcH-2wY,8229
 biolib/_runtime/runtime.py,sha256=bZQ0m39R9jOBVAtlyvzDnOobKueOAQUCwMUZjDQnO7E,4439
+biolib/_session/session.py,sha256=K-mbWKP6zMEdKha4Key6XEqRvduS_Ol4LgAVjf37tO4,1341
 biolib/api/__init__.py,sha256=mQ4u8FijqyLzjYMezMUUbbBGNB3iFmkNdjXnWPZ7Jlw,138
-biolib/api/client.py,sha256=EN3lDbbgWxw3aPDe8W5XIU6WkMfOHW7Dmsz-R6QqxAw,4176
+biolib/api/client.py,sha256=pILuZhmWCXGuzrp9rPwtwRizvIGGbIlT2o4wV-vwL24,7668
 biolib/app/__init__.py,sha256=cdPtcfb_U-bxb9iSL4fCEq2rpD9OjkyY4W-Zw60B0LI,37
-biolib/app/app.py,sha256=-Ed4wV3RSMIq7DgQqCHkzkooyr2RRzoUuOAtJRl3E5E,9622
+biolib/app/app.py,sha256=HxW3T1iuDh-DMhVDB0NbgQjRXqgE7dPw8CAdhrd5lbw,9940
 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=ohvbWbpresxLHFGPkvXACfmiTYsBk8RBx5XsBbLYg_M,7546
 biolib/biolib_api_client/app_types.py,sha256=1sXz9XnLRKNALMglNdTbew7AL6OkcUan0MPdj4xQLis,2456
 biolib/biolib_api_client/auth.py,sha256=kjm0ZHnH3I8so3su2sZbBxNHYp-ZUdrZ5lwQ0K36RSw,949
-biolib/biolib_api_client/biolib_app_api.py,sha256=RUXrTxk7XKzm4wxv7NBXttuFjT60DI9vNOvkS-cjKNc,5065
-biolib/biolib_api_client/biolib_job_api.py,sha256=49SBozudLYlOByuQMABiHZkwK5Jt5_orjv8Vw0rJpks,7306
+biolib/biolib_api_client/biolib_app_api.py,sha256=DdE_kRfDgVa876Cdl_D1P0lBoaghFomEyy-ZP8K7SoY,5177
+biolib/biolib_api_client/biolib_job_api.py,sha256=3Hzv5Os4d377pKrCzg3i7c5xiy9FiqeVssub690GLdA,7423
 biolib/biolib_api_client/common_types.py,sha256=RH-1KNHqUF-EkTpfPOSTt5Mq1GPdfju_cqXDesscO1I,123
 biolib/biolib_api_client/job_types.py,sha256=yBdBwjharbQJuXCi2xKMi0t_r6XxnbWnkchHekTpCJY,1351
 biolib/biolib_api_client/lfs_types.py,sha256=joZWP6-sa5_Ug_6xIp5fHAgEo_bqLE3rbleQocZtDcg,339
@@ -101,12 +102,12 @@ biolib/compute_node/webserver/worker_thread.py,sha256=7uD9yQPhePYvP2HCJ27EeZ_h6p
 biolib/experiments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/experiments/experiment.py,sha256=pBtnOHz0kKoFxlIGf08o8ZCEOze-CljwfOsTdhvCTCk,8646
 biolib/jobs/__init__.py,sha256=aIb2H2DHjQbM2Bs-dysFijhwFcL58Blp0Co0gimED3w,32
-biolib/jobs/job.py,sha256=vmALUOA9APqz0qTjmlisT6ChZHUwOaTlX-1VLhWJSrA,23176
+biolib/jobs/job.py,sha256=v6q7QbQWKeNCl5Sog912aduboq7PU1l4vhOVhlZewEI,23591
 biolib/jobs/job_result.py,sha256=rALHiKYNaC9lHi_JJqBob1RubzNLwG9Z386kwRJjd2M,5885
 biolib/jobs/types.py,sha256=ezvaoTANsWazK6PmfpYcqezdfjP7MNBEBfqIZGoZhz8,997
 biolib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/runtime/__init__.py,sha256=MlRepA11n2H-3plB5rzWyyHK2JmP6PiaP3i6x3vt0mg,506
-biolib/sdk/__init__.py,sha256=8uyOAKt8-Xo11jAWXCg14NkE1u0FkOBC07L3V7wGsCg,1960
+biolib/sdk/__init__.py,sha256=fvSPXe4JC4uq75-y7LGrn3C7VFrQ-1I6Yp6SF5oG2DY,2179
 biolib/tables.py,sha256=MmruV-nJLc3HbLVJBAiDuDCgS2-4oaUkpoCLLUNYbxQ,1173
 biolib/templates/__init__.py,sha256=Yx62sSyDCDesRQDQgmbDsLpfgEh93fWE8r9u4g2azXk,36
 biolib/templates/example_app.py,sha256=EB3E3RT4SeO_ii5nVQqJpi5KDGNE_huF1ub-e5ZFveE,715
@@ -119,8 +120,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=Ozk0blGtPur_D9MwShD02r_mphyQmgZkx-lOHOwnlIM,6730
 biolib/utils/zip/remote_zip.py,sha256=0wErYlxir5921agfFeV1xVjf29l9VNgGQvNlWOlj2Yc,23232
-pybiolib-1.2.567.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
-pybiolib-1.2.567.dist-info/METADATA,sha256=cYbTCTlMWjLsgfbKKtLkHmAn3WZ2ezprxNiAadnwqmo,1570
-pybiolib-1.2.567.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pybiolib-1.2.567.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
-pybiolib-1.2.567.dist-info/RECORD,,
+pybiolib-1.2.582.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+pybiolib-1.2.582.dist-info/METADATA,sha256=EXVefv4YrS8ZoOBerWf0yDWbEHE_LIGzj5QLbzeZ2SY,1570
+pybiolib-1.2.582.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+pybiolib-1.2.582.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
+pybiolib-1.2.582.dist-info/RECORD,,