pybiolib 1.1.1629__py3-none-any.whl → 1.1.1881__py3-none-any.whl

biolib/__init__.py

@@ -1,5 +1,6 @@
 # Imports to hide
 import os
+from urllib.parse import urlparse as _urlparse
 
 from biolib import typing_utils as _typing_utils
 from biolib.app import BioLibApp as _BioLibApp
@@ -12,10 +13,12 @@ from biolib.biolib_api_client import BiolibApiClient as _BioLibApiClient, App
 from biolib.jobs import Job as _Job
 from biolib import user as _user
 from biolib.typing_utils import List, Optional
+from biolib._internal.data_record import DataRecord as _DataRecord
 
 import biolib.api
 import biolib.app
 import biolib.cli
+import biolib.sdk
 import biolib.utils
 
 
@@ -32,8 +35,8 @@ def load(uri: str) -> _BioLibApp:
 def search(
         search_query: Optional[str] = None,
         team: Optional[str] = None,
-        count: int = 100
-    ) -> List[str]:
+        count: int = 100,
+) -> List[str]:
     apps: List[str] = search_apps(search_query, team, count)
     return apps
 
@@ -46,6 +49,10 @@ def fetch_jobs(count: int = 25) -> List[_Job]:
     return _Job.fetch_jobs(count)
 
 
+def fetch_data_records(uri: Optional[str] = None, count: Optional[int] = None) -> List[_DataRecord]:
+    return _DataRecord.fetch(uri, count)
+
+
 def get_experiment(name: str) -> Experiment:
     return Experiment(name)
 
@@ -77,6 +84,7 @@ def logout() -> None:
 def set_api_base_url(api_base_url: str) -> None:
     _BioLibApiClient.initialize(base_url=api_base_url)
     biolib.utils.BIOLIB_BASE_URL = api_base_url
+    biolib.utils.BIOLIB_SITE_HOSTNAME = _urlparse(api_base_url).hostname
     biolib.utils.BASE_URL_IS_PUBLIC_BIOLIB = api_base_url.endswith('biolib.com') or (
             os.environ.get('BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB', '').upper() == 'TRUE'
     )
@@ -127,4 +135,4 @@ _logger.configure(default_log_level=_DEFAULT_LOG_LEVEL)
 _logger_no_user_data.configure(default_log_level=_DEFAULT_LOG_LEVEL)
 _configure_requests_certificates()
 
-set_api_base_url(biolib.utils.BIOLIB_BASE_URL)
+set_api_base_url(biolib.utils.load_base_url_from_env())

biolib/_internal/data_record/__init__.py

@@ -0,0 +1 @@
+from .data_record import DataRecord

biolib/_internal/data_record/data_record.py

@@ -0,0 +1,153 @@
+import os
+from collections import namedtuple
+from datetime import datetime
+from fnmatch import fnmatch
+from struct import Struct
+from typing import Callable, Dict, List, Optional, Union, cast
+
+from biolib import lfs
+from biolib._internal.data_record.remote_storage_endpoint import DataRecordRemoteStorageEndpoint
+from biolib._internal.http_client import HttpClient
+from biolib.api import client as api_client
+from biolib.biolib_api_client import AppGetResponse
+from biolib.biolib_binary_format import LazyLoadedFile
+from biolib.biolib_binary_format.utils import RemoteIndexableBuffer
+from biolib.biolib_logging import logger
+from biolib.utils.app_uri import parse_app_uri
+from biolib.utils.zip.remote_zip import RemoteZip  # type: ignore
+
+PathFilter = Union[str, Callable[[str], bool]]
+
+
+class DataRecord:
+    def __init__(self, uri: str):
+        self._uri = uri
+        uri_parsed = parse_app_uri(uri, use_account_as_name_default=False)
+        if not uri_parsed['app_name']:
+            raise ValueError('Expected parameter "uri" to contain resource name')
+
+        self._name = uri_parsed['app_name']
+
+    @property
+    def uri(self) -> str:
+        return self._uri
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def list_files(self, path_filter: Optional[PathFilter] = None) -> List[LazyLoadedFile]:
+        app_response: AppGetResponse = api_client.get(path='/app/', params={'uri': self._uri}).json()
+        remote_storage_endpoint = DataRecordRemoteStorageEndpoint(
+            resource_version_uuid=app_response['app_version']['public_id'],
+        )
+        files: List[LazyLoadedFile] = []
+        with RemoteZip(url=remote_storage_endpoint.get_remote_url()) as remote_zip:
+            central_directory = remote_zip.get_central_directory()
+            for file_info in central_directory.values():
+                files.append(self._get_file(remote_storage_endpoint, file_info))
+
+        return self._get_filtered_files(files=files, path_filter=path_filter) if path_filter else files
+
+    def download_files(self, output_dir: str, path_filter: Optional[PathFilter] = None) -> None:
+        filtered_files = self.list_files(path_filter=path_filter)
+
+        if len(filtered_files) == 0:
+            logger.debug('No files to save')
+            return
+
+        for file in filtered_files:
+            file_path = os.path.join(output_dir, file.path)
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, mode='wb') as file_handle:
+                file_handle.write(file.get_data())
+
+    def save_files(self, output_dir: str, path_filter: Optional[PathFilter] = None) -> None:
+        self.download_files(output_dir=output_dir, path_filter=path_filter)
+
+    @staticmethod
+    def create(destination: str, data_path: str, name: Optional[str] = None) -> 'DataRecord':
+        assert os.path.isdir(data_path), f'The path "{data_path}" is not a directory.'
+        record_name = name if name else 'data-record-' + datetime.now().isoformat().split('.')[0].replace(':', '-')
+        record_uri = lfs.create_large_file_system(lfs_uri=f'{destination}/{record_name}')
+        record_version_uri = lfs.push_large_file_system(lfs_uri=record_uri, input_dir=data_path)
+        return DataRecord(uri=record_version_uri)
+
+    @staticmethod
+    def fetch(uri: Optional[str] = None, count: Optional[int] = None) -> List['DataRecord']:
+        max_page_size = 1_000
+        params: Dict[str, Union[str, int]] = {
+            'page_size': str(count or max_page_size),
+            'resource_type': 'data-record',
+        }
+        if uri:
+            uri_parsed = parse_app_uri(uri, use_account_as_name_default=False)
+            params['account_handle'] = uri_parsed['account_handle_normalized']
+
+        results = api_client.get(path='/apps/', params=params).json()['results']
+        if count is None and len(results) == max_page_size:
+            logger.warning(
+                f'Fetch results exceeded maximum count of {max_page_size}. Some data records might not be fetched.'
+            )
+
+        return [DataRecord(result['resource_uri']) for result in results]
+
+    @staticmethod
+    def _get_file(remote_storage_endpoint: DataRecordRemoteStorageEndpoint, file_info: Dict) -> LazyLoadedFile:
+        local_file_header_signature_bytes = b'\x50\x4b\x03\x04'
+        local_file_header_struct = Struct('<H2sHHHIIIHH')
+        LocalFileHeader = namedtuple(
+            'LocalFileHeader',
+            (
+                'version',
+                'flags',
+                'compression_raw',
+                'mod_time',
+                'mod_date',
+                'crc_32_expected',
+                'compressed_size_raw',
+                'uncompressed_size_raw',
+                'file_name_len',
+                'extra_field_len',
+            ),
+        )
+
+        local_file_header_start = file_info['header_offset'] + len(local_file_header_signature_bytes)
+        local_file_header_end = local_file_header_start + local_file_header_struct.size
+
+        def file_start_func() -> int:
+            local_file_header_response = HttpClient.request(
+                url=remote_storage_endpoint.get_remote_url(),
+                headers={'range': f'bytes={local_file_header_start}-{local_file_header_end - 1}'},
+                timeout_in_seconds=300,
+            )
+            local_file_header = LocalFileHeader._make(
+                local_file_header_struct.unpack(local_file_header_response.content)
+            )
+            file_start: int = (
+                local_file_header_end + local_file_header.file_name_len + local_file_header.extra_field_len
+            )
+            return file_start
+
+        return LazyLoadedFile(
+            buffer=RemoteIndexableBuffer(endpoint=remote_storage_endpoint),
+            length=file_info['file_size'],
+            path=file_info['filename'],
+            start=None,
+            start_func=file_start_func,
+        )
+
+    @staticmethod
+    def _get_filtered_files(files: List[LazyLoadedFile], path_filter: PathFilter) -> List[LazyLoadedFile]:
+        if not (isinstance(path_filter, str) or callable(path_filter)):
+            raise Exception('Expected path_filter to be a string or a function')
+
+        if callable(path_filter):
+            return list(filter(lambda x: path_filter(x.path), files))  # type: ignore
+
+        glob_filter = cast(str, path_filter)
+
+        def _filter_function(file: LazyLoadedFile) -> bool:
+            return fnmatch(file.path, glob_filter)
+
+        return list(filter(_filter_function, files))

biolib/_internal/data_record/remote_storage_endpoint.py

@@ -0,0 +1,27 @@
+from datetime import datetime, timedelta
+
+from biolib.api import client as api_client
+from biolib.biolib_api_client.lfs_types import LargeFileSystemVersion
+from biolib.biolib_binary_format.utils import RemoteEndpoint
+from biolib.biolib_logging import logger
+
+
+class DataRecordRemoteStorageEndpoint(RemoteEndpoint):
+    def __init__(self, resource_version_uuid: str):
+        self._resource_version_uuid: str = resource_version_uuid
+        self._expires_at = None
+        self._presigned_url = None
+
+    def get_remote_url(self):
+        if not self._presigned_url or datetime.utcnow() > self._expires_at:
+            lfs_version: LargeFileSystemVersion = api_client.get(
+                path=f'/lfs/versions/{self._resource_version_uuid}/',
+            ).json()
+            self._presigned_url = lfs_version['presigned_download_url']
+            self._expires_at = datetime.utcnow() + timedelta(minutes=8)
+            logger.debug(
+                f'DataRecord "{self._resource_version_uuid}" fetched presigned URL '
+                f'with expiry at {self._expires_at.isoformat()}'
+            )
+
+        return self._presigned_url

biolib/_internal/http_client.py

@@ -1,12 +1,28 @@
 import json
-import time
+import platform
 import socket
-import urllib.request
+import ssl
+import subprocess
+import time
 import urllib.error
 import urllib.parse
+import urllib.request
 
 from biolib.biolib_logging import logger_no_user_data
-from biolib.typing_utils import Dict, Optional, Union, Literal, cast
+from biolib.typing_utils import Dict, Literal, Optional, Union, cast
+
+_HttpMethod = Literal['GET', 'POST', 'PATCH', 'PUT']
+
+
+def _create_ssl_context():
+    context = ssl.create_default_context()
+    try:
+        if platform.system() == 'Darwin':
+            certificates = subprocess.check_output('security find-certificate -a -p', shell=True).decode('utf-8')
+            context.load_verify_locations(cadata=certificates)
+    except BaseException:
+        pass
+    return context
 
 
 class HttpError(urllib.error.HTTPError):
@@ -16,7 +32,7 @@ class HttpError(urllib.error.HTTPError):
             code=http_error.code,
             msg=http_error.msg,  # type: ignore
             hdrs=http_error.hdrs,  # type: ignore
-            fp=http_error.fp
+            fp=http_error.fp,
         )
 
     def __str__(self):
@@ -25,10 +41,11 @@ class HttpError(urllib.error.HTTPError):
 
 
 class HttpResponse:
-    def __init__(self, response):
-        self.status_code = response.status
-        self.content = response.read()
-        self.url = response.geturl()
+    def __init__(self, response) -> None:
+        self.headers: Dict[str, str] = dict(response.headers)
+        self.status_code: int = int(response.status)
+        self.content: bytes = response.read()
+        self.url: str = response.geturl()
 
     @property
     def text(self) -> str:
@@ -39,14 +56,19 @@ class HttpResponse:
 
 
 class HttpClient:
+    ssl_context = None
+
     @staticmethod
     def request(
-            url: str,
-            method: Optional[Literal['GET', 'POST', 'PATCH']] = None,
-            data: Optional[Union[Dict, bytes]] = None,
-            headers: Optional[Dict[str, str]] = None,
-            retries: int = 0,
+        url: str,
+        method: Optional[_HttpMethod] = None,
+        data: Optional[Union[Dict, bytes]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        retries: int = 5,
+        timeout_in_seconds: Optional[int] = None,
     ) -> HttpResponse:
+        if not HttpClient.ssl_context:
+            HttpClient.ssl_context = _create_ssl_context()
         headers_to_send = headers or {}
         if isinstance(data, dict):
             headers_to_send['Accept'] = 'application/json'
@@ -58,7 +80,8 @@ class HttpClient:
             headers=headers_to_send,
             method=method or 'GET',
         )
-        timeout_in_seconds = 60 if isinstance(data, dict) else 180  # TODO: Calculate timeout based on data size
+        if timeout_in_seconds is None:
+            timeout_in_seconds = 60 if isinstance(data, dict) else 180  # TODO: Calculate timeout based on data size
 
         last_error: Optional[urllib.error.URLError] = None
         for retry_count in range(retries + 1):
@@ -66,13 +89,20 @@ class HttpClient:
                 time.sleep(5 * retry_count)
                 logger_no_user_data.debug(f'Retrying HTTP {method} request...')
             try:
-                with urllib.request.urlopen(request, timeout=timeout_in_seconds) as response:
+                with urllib.request.urlopen(
+                    request,
+                    context=HttpClient.ssl_context,
+                    timeout=timeout_in_seconds,
+                ) as response:
                     return HttpResponse(response)
 
             except urllib.error.HTTPError as error:
                 if error.code == 502:
                     logger_no_user_data.debug(f'HTTP {method} request failed with status 502 for "{url}"')
                     last_error = error
+                elif error.code == 503:
+                    logger_no_user_data.debug(f'HTTP {method} request failed with status 503 for "{url}"')
+                    last_error = error
                 else:
                     raise HttpError(error) from None
 

biolib/_internal/push_application.py

@@ -1,17 +1,18 @@
 import os
 import re
 from pathlib import Path
-import yaml
+
 import rich.progress
+import yaml
 
-from biolib.lfs.utils import get_iterable_zip_stream, get_files_and_size_of_directory
-from biolib.typing_utils import Optional, Set, TypedDict, Iterable
+from biolib import api, utils
 from biolib.biolib_api_client import BiolibApiClient
-from biolib.biolib_docker_client import BiolibDockerClient
 from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
+from biolib.biolib_docker_client import BiolibDockerClient
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger
-from biolib import utils, api
+from biolib.lfs.utils import get_files_and_size_of_directory, get_iterable_zip_stream
+from biolib.typing_utils import Iterable, Optional, Set, TypedDict
 
 REGEX_MARKDOWN_INLINE_IMAGE = re.compile(r'!\[(?P<alt>.*)\]\((?P<src>.*)\)')
 
@@ -38,9 +39,7 @@ def process_docker_status_updates(status_updates: Iterable[DockerStatusUpdate],
                 progress_detail = update['progressDetail']
 
                 if layer_id not in layer_id_to_task_id:
-                    layer_id_to_task_id[layer_id] = progress.add_task(
-                        description=f'[cyan]{action} layer {layer_id}'
-                    )
+                    layer_id_to_task_id[layer_id] = progress.add_task(description=f'[cyan]{action} layer {layer_id}')
 
                 if progress_detail and 'current' in progress_detail and 'total' in progress_detail:
                     progress.update(
@@ -60,7 +59,7 @@ def process_docker_status_updates(status_updates: Iterable[DockerStatusUpdate],
 
 
 def set_app_version_as_active(
-        app_version_uuid: str,
+    app_version_uuid: str,
 ):
     logger.debug(f'Setting app version {app_version_uuid} as active.')
     api.client.patch(
@@ -70,10 +69,10 @@ def set_app_version_as_active(
 
 
 def push_application(
-        app_uri: str,
-        app_path: str,
-        app_version_to_copy_images_from: Optional[str],
-        is_dev_version: Optional[bool],
+    app_uri: str,
+    app_path: str,
+    app_version_to_copy_images_from: Optional[str],
+    is_dev_version: Optional[bool],
 ):
     app_path_absolute = Path(app_path).resolve()
 
@@ -96,7 +95,7 @@ def push_application(
 
     input_files_maps_to_root = False
     try:
-        with open(config_yml_path, mode='r') as config_yml_file:
+        with open(config_yml_path) as config_yml_file:
             config = yaml.safe_load(config_yml_file.read())
 
         license_file_relative_path = config.get('license_file', 'LICENSE')
@@ -109,7 +108,7 @@ def push_application(
             raise BioLibError(f'Could not find {description_file_relative_path}')
 
         zip_filters.add(description_file_relative_path)
-        with open(description_file_absolute_path, mode='r') as description_file:
+        with open(description_file_absolute_path) as description_file:
             description_file_content = description_file.read()
 
         for _, img_src_path in re.findall(REGEX_MARKDOWN_INLINE_IMAGE, description_file_content):
@@ -171,8 +170,9 @@ def push_application(
         author=app['account_handle'],
         set_as_active=False,
         zip_binary=source_files_zip_bytes,
-        app_version_id_to_copy_images_from=app_response['app_version']['public_id'] if app_version_to_copy_images_from
-        else None
+        app_version_id_to_copy_images_from=app_response['app_version']['public_id']
+        if app_version_to_copy_images_from
+        else None,
     )
 
     #  Don't push docker images if copying from another app version
@@ -180,18 +180,6 @@ def push_application(
     if not app_version_to_copy_images_from and docker_tags:
         logger.info('Found docker images to push.')
 
-        try:
-            yaml_file = open(f'{app_path}/.biolib/config.yml', 'r', encoding='utf-8')
-
-        except Exception as error:  # pylint: disable=broad-except
-            raise BioLibError('Could not open the config file .biolib/config.yml') from error
-
-        try:
-            config_data = yaml.safe_load(yaml_file)
-
-        except Exception as error:  # pylint: disable=broad-except
-            raise BioLibError('Could not parse .biolib/config.yml. Please make sure it is valid YAML') from error
-
         # Auth to be sent to proxy
         # The tokens are sent as "{access_token},{job_id}". We leave job_id blank on push.
         tokens = f'{BiolibApiClient.get().access_token},'
@@ -200,14 +188,12 @@ def push_application(
         docker_client = BiolibDockerClient.get_docker_client()
 
         for module_name, repo_and_tag in docker_tags.items():
-            docker_image_definition = config_data['modules'][module_name]['image']
+            docker_image_definition = config['modules'][module_name]['image']
             repo, tag = repo_and_tag.split(':')
 
             if docker_image_definition.startswith('dockerhub://'):
                 docker_image_name = docker_image_definition.replace('dockerhub://', 'docker.io/', 1)
-                logger.info(
-                    f'Pulling image {docker_image_name} defined on module {module_name} from Dockerhub.'
-                )
+                logger.info(f'Pulling image {docker_image_name} defined on module {module_name} from Dockerhub.')
                 dockerhub_repo, dockerhub_tag = docker_image_name.split(':')
                 pull_status_updates: Iterable[DockerStatusUpdate] = docker_client.api.pull(
                     decode=True,
@@ -238,7 +224,7 @@ def push_application(
 
                 process_docker_status_updates(push_status_updates, action='Pushing')
 
-            except Exception as exception:  # pylint: disable=broad-except
+            except Exception as exception:
                 raise BioLibError(f'Failed to tag and push image {docker_image_name}.') from exception
 
             logger.info(f'Successfully pushed {docker_image_name}')
@@ -249,10 +235,9 @@ def push_application(
         data={'set_as_active': not is_dev_version},
     )
 
-    sematic_version = \
-        f"{new_app_version_json['major']}.{new_app_version_json['minor']}.{new_app_version_json['patch']}"
+    sematic_version = f"{new_app_version_json['major']}.{new_app_version_json['minor']}.{new_app_version_json['patch']}"
     logger.info(
         f"Successfully pushed new {'development ' if is_dev_version else ''}version {sematic_version} of {app_uri}."
     )
 
-    return {"app_uri": app_uri, "sematic_version": sematic_version}
+    return {'app_uri': app_uri, 'sematic_version': sematic_version}

biolib/_internal/runtime.py

@@ -0,0 +1,73 @@
+import json
+
+from biolib import api
+from biolib.typing_utils import Optional, TypedDict, cast
+
+
+class RuntimeJobDataDict(TypedDict):
+    version: str
+    job_requested_machine: str
+    job_uuid: str
+    job_auth_token: str
+
+
+class BioLibRuntimeError(Exception):
+    pass
+
+
+class BioLibRuntimeNotRecognizedError(BioLibRuntimeError):
+    def __init__(self, message='The runtime is not recognized as a BioLib app'):
+        self.message = message
+        super().__init__(self.message)
+
+
+class Runtime:
+    _job_data: Optional[RuntimeJobDataDict] = None
+
+    @staticmethod
+    def check_is_environment_biolib_app() -> bool:
+        return bool(Runtime._try_to_get_job_data())
+
+    @staticmethod
+    def get_job_id() -> str:
+        return Runtime._get_job_data()['job_uuid']
+
+    @staticmethod
+    def get_job_auth_token() -> str:
+        return Runtime._get_job_data()['job_auth_token']
+
+    @staticmethod
+    def get_job_requested_machine() -> str:
+        return Runtime._get_job_data()['job_requested_machine']
+
+    @staticmethod
+    def set_main_result_prefix(result_prefix: str) -> None:
+        job_data = Runtime._get_job_data()
+        api.client.patch(
+            data={'result_name_prefix': result_prefix},
+            headers={'Job-Auth-Token': job_data['job_auth_token']},
+            path=f"/jobs/{job_data['job_uuid']}/main_result/",
+        )
+
+    @staticmethod
+    def _try_to_get_job_data() -> Optional[RuntimeJobDataDict]:
+        if not Runtime._job_data:
+            try:
+                with open('/biolib/secrets/biolib_system_secret') as file:
+                    job_data: RuntimeJobDataDict = json.load(file)
+            except BaseException:
+                return None
+
+            if not job_data['version'].startswith('1.'):
+                raise BioLibRuntimeError(f"Unexpected system secret version {job_data['version']} expected 1.x.x")
+
+            Runtime._job_data = job_data
+
+        return cast(RuntimeJobDataDict, Runtime._job_data)
+
+    @staticmethod
+    def _get_job_data() -> RuntimeJobDataDict:
+        job_data = Runtime._try_to_get_job_data()
+        if not job_data:
+            raise BioLibRuntimeNotRecognizedError() from None
+        return job_data

biolib/_internal/utils/__init__.py

@@ -0,0 +1,18 @@
+import time
+import uuid
+
+
+def open_browser_window_from_notebook(url_to_open: str) -> None:
+    try:
+        from IPython.display import (  # type:ignore # pylint: disable=import-error, import-outside-toplevel
+            Javascript,
+            display,
+            update_display,
+        )
+    except ImportError as error:
+        raise Exception('Unexpected environment. This function can only be called from a notebook.') from error
+
+    display_id = str(uuid.uuid4())
+    display(Javascript(f'window.open("{url_to_open}");'), display_id=display_id)
+    time.sleep(1)
+    update_display(Javascript(''), display_id=display_id)

biolib/api/client.py

@@ -4,7 +4,10 @@ from biolib.typing_utils import Dict, Optional, Union
 from biolib.biolib_api_client import BiolibApiClient as DeprecatedApiClient
 from biolib._internal.http_client import HttpResponse, HttpClient
 
-OptionalHeaders = Optional[Dict[str, Union[str, None]]]
+OptionalHeaders = Union[
+    Optional[Dict[str, str]],
+    Optional[Dict[str, Union[str, None]]],
+]
 
 
 class ApiClient(HttpClient):
@@ -14,11 +17,12 @@ class ApiClient(HttpClient):
             params: Optional[Dict[str, Union[str, int]]] = None,
             headers: OptionalHeaders = None,
             authenticate: bool = True,
+            retries: int = 10,
     ) -> HttpResponse:
         return self.request(
             headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
             method='GET',
-            retries=10,
+            retries=retries,
             url=self._get_absolute_url(path=path, query_params=params),
         )
 
@@ -27,21 +31,23 @@ class ApiClient(HttpClient):
             path: str,
             data: Optional[Union[Dict, bytes]] = None,
             headers: OptionalHeaders = None,
+            authenticate: bool = True,
+            retries: int = 5,
     ) -> HttpResponse:
         return self.request(
             data=data,
-            headers=self._get_headers(opt_headers=headers, authenticate=True),
+            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
             method='POST',
-            retries=3,
+            retries=retries,
             url=self._get_absolute_url(path=path, query_params=None),
         )
 
-    def patch(self, path: str, data: Dict, headers: OptionalHeaders = None) -> HttpResponse:
+    def patch(self, path: str, data: Dict, headers: OptionalHeaders = None, retries: int = 5) -> HttpResponse:
         return self.request(
             data=data,
             headers=self._get_headers(opt_headers=headers, authenticate=True),
             method='PATCH',
-            retries=0,
+            retries=retries,
             url=self._get_absolute_url(path=path, query_params=None),
         )
 

biolib/app/app.py

@@ -263,7 +263,12 @@ Example: "app.cli('--help')"
             if not key.startswith('--'):
                 key = f'--{key}'
 
-            args.extend([key, value])
+            args.append(key)
+            if isinstance(value, list):
+                # TODO: only do this if argument key is of type file list
+                args.extend(value)
+            else:
+                args.append(value)
 
         return self.cli(args, **biolib_kwargs)