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

biolib/__init__.py

@@ -13,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
 
 
@@ -33,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
 
@@ -47,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)
 

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,25 +1,24 @@
 import json
 import platform
-import time
 import socket
 import ssl
 import subprocess
-import urllib.request
+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')
+            certificates = subprocess.check_output('security find-certificate -a -p', shell=True).decode('utf-8')
             context.load_verify_locations(cadata=certificates)
     except BaseException:
         pass
@@ -33,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):
@@ -42,7 +41,7 @@ class HttpError(urllib.error.HTTPError):
 
 
 class HttpResponse:
-    def __init__(self, response):
+    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()
@@ -61,12 +60,12 @@ class HttpClient:
 
     @staticmethod
     def request(
-            url: str,
-            method: Optional[Literal['GET', 'POST', 'PATCH', 'PUT']] = None,
-            data: Optional[Union[Dict, bytes]] = None,
-            headers: Optional[Dict[str, str]] = None,
-            retries: int = 5,
-            timeout_in_seconds: Optional[int] = None,
+        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()

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

biolib/app/search_apps.py

@@ -7,41 +7,37 @@ from biolib.typing_utils import Optional, List
 def search_apps(
         search_query: Optional[str] = None,
         team: Optional[str] = None,
-        count: int = 100
-    ) -> List[str]:
-
+        count: int = 100,
+) -> List[str]:
     query_exceeded_page_size = False
     params = {
         'page_size': count,
     }
     if team:
-        if not team.startswith("@"):
-            team = "@biolib.com/" + team
+        if not team.startswith('@'):
+            team = '@biolib.com/' + team
         params['account_handle'] = team
 
     if search_query:
         params['search'] = search_query
 
-    apps_json = api.client.get(
-        path='/apps/',
-        params=params
-    ).json()
+    apps_json = api.client.get(path='/apps/', params=params).json()
     if apps_json['count'] > count:
         query_exceeded_page_size = True
 
     apps = [app['resource_uri'] for app in apps_json['results']]
 
-    if not utils.BASE_URL_IS_PUBLIC_BIOLIB and (not team or team.lower().startswith("@biolib.com")):
+    if not utils.BASE_URL_IS_PUBLIC_BIOLIB and (not team or team.lower().startswith('@biolib.com')):
         # Also get federated apps if running on enterprise deployment
         public_biolib_apps_json = api.client.get(
             authenticate=False,
             path='https://biolib.com/api/apps/',
-            params=params
+            params=params,
         ).json()
         if public_biolib_apps_json['count'] > count:
             query_exceeded_page_size = True
 
-        apps.extend([f'@biolib.com/{app["resource_uri"]}' for app in public_biolib_apps_json['results']])
+        apps.extend([f"@biolib.com/{app['resource_uri']}" for app in public_biolib_apps_json['results']])
 
     if query_exceeded_page_size:
         print(f'Search results exceeded {count}, use the argument "count" to increase the amount of results returned')

biolib/biolib_api_client/api_client.py

@@ -6,6 +6,7 @@ import os
 from datetime import datetime, timezone
 from json.decoder import JSONDecodeError
 
+from biolib._internal.runtime import Runtime
 from biolib._internal.http_client import HttpClient
 from biolib.typing_utils import Optional
 from biolib.biolib_errors import BioLibError
@@ -61,16 +62,18 @@ class _ApiClient:
             return
 
         if self.access_token:
-            decoded_token = self._decode_jwt_without_checking_signature(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
 
         # 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})
+            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
@@ -111,9 +114,11 @@ class _ApiClient:
     def sign_in_with_api_token(self, api_token: str) -> None:
         logger_no_user_data.debug('ApiClient: Signing in with BIOLIB_TOKEN...')
         try:
-            response = HttpClient.request(method='POST',
-                                        url=f'{self.base_url}/api/user/api_tokens/exchange/',
-                                        data={'token': api_token})
+            response = HttpClient.request(
+                method='POST',
+                url=f'{self.base_url}/api/user/api_tokens/exchange/',
+                data={'token': api_token},
+            )
         except Exception as exception:
             logger.error('Sign in with API token failed')
             raise exception
@@ -127,7 +132,7 @@ class _ApiClient:
         self.refresh_token = json_response['refresh_token']
 
     @staticmethod
-    def _decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
+    def decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
         jwt_bytes = jwt.encode('utf-8')
 
         try:
@@ -189,7 +194,7 @@ class BiolibApiClient:
     @staticmethod
     def assert_is_signed_in(authenticated_action_description: str) -> None:
         api_client = BiolibApiClient.get()
-        if not api_client.is_signed_in:
+        if not api_client.is_signed_in and not Runtime.check_is_environment_biolib_app():
             raise BioLibError(
                 f'You must be signed in to {authenticated_action_description}. '
                 f'Please set the environment variable "BIOLIB_TOKEN"'

biolib/biolib_api_client/app_types.py

@@ -99,6 +99,7 @@ class _AppVersionOnJob(TypedDict):
 
 class AppOnJob(TypedDict):
     allow_client_side_execution: bool
+    can_push_data_record_for_user: bool
     state: Literal['public', 'draft']
 
 

biolib/biolib_api_client/biolib_app_api.py

@@ -35,7 +35,7 @@ def encode_multipart(data, files):
     line_array.append('')
 
     data_encoded = b'\r\n'.join([line.encode() if isinstance(line, str) else line for line in line_array])
-    return 'multipart/form-data; boundary={}'.format(boundary), data_encoded
+    return f'multipart/form-data; boundary={boundary}', data_encoded
 
 
 def _get_git_branch_name() -> str: