pybiolib 1.2.883__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/_internal/add_copilot_prompts.py

@@ -2,10 +2,10 @@ import os
 import shutil
 import sys
 
-from biolib._internal import llm_instructions
+from biolib._internal.templates import templates
 
 
-def add_copilot_prompts(force: bool, style: bool = True, silent: bool = False) -> None:
+def add_copilot_prompts(force: bool, silent: bool = False) -> None:
     current_working_directory = os.getcwd()
     config_file_path = f'{current_working_directory}/.biolib/config.yml'
     if not os.path.exists(config_file_path):
@@ -14,32 +14,45 @@ Error: Current directory has not been initialized as a BioLib application.
        Please run the \"biolib init\" command first"""
         print(err_string, file=sys.stderr)
         exit(1)
-    source_path = os.path.join(os.path.dirname(llm_instructions.__file__), '.github')
+    source_path = os.path.join(templates.copilot_template(), '.github')
     destination_path = os.path.join(current_working_directory, '.github')
 
     conflicting_files = []
+    files_to_overwrite = set()
 
     for root, _, filenames in os.walk(source_path):
         relative_dir = os.path.relpath(root, source_path)
         destination_dir = os.path.join(destination_path, relative_dir)
         for filename in filenames:
-            if 'style' in filename and not style:
-                continue
             source_file = os.path.join(root, filename)
             destination_file = os.path.join(destination_dir, filename)
             if os.path.exists(destination_file) and not force:
                 with open(source_file, 'rb') as fsrc, open(destination_file, 'rb') as fdest:
                     if fsrc.read() != fdest.read():
                         conflicting_files.append(os.path.relpath(destination_file, current_working_directory))
-            else:
-                os.makedirs(destination_dir, exist_ok=True)
-                shutil.copy2(source_file, destination_file)
 
     if conflicting_files:
-        print('The following files were not overwritten. Use --force to override them:', file=sys.stderr)
+        print('The following files already exist and would be overwritten:')
         for conflicting_file in conflicting_files:
-            print(f'  {conflicting_file}', file=sys.stderr)
-        exit(1)
+            print(f'  {conflicting_file}')
+        print()
+
+        for conflicting_file in conflicting_files:
+            choice = input(f'Overwrite {conflicting_file}? [y/N]: ').lower().strip()
+            if choice in ['y', 'yes']:
+                files_to_overwrite.add(conflicting_file)
+
+    for root, _, filenames in os.walk(source_path):
+        relative_dir = os.path.relpath(root, source_path)
+        destination_dir = os.path.join(destination_path, relative_dir)
+        for filename in filenames:
+            source_file = os.path.join(root, filename)
+            destination_file = os.path.join(destination_dir, filename)
+            relative_file_path = os.path.relpath(destination_file, current_working_directory)
+
+            if not os.path.exists(destination_file) or force or relative_file_path in files_to_overwrite:
+                os.makedirs(destination_dir, exist_ok=True)
+                shutil.copy2(source_file, destination_file)
 
     if not silent:
         print(f'Prompt and instruction files added to {destination_path}/')

biolib/_internal/add_gui_files.py

@@ -0,0 +1,81 @@
+import os
+import shutil
+
+from biolib._internal.templates import templates
+
+
+def add_gui_files(force=False, silent=False) -> None:
+    cwd = os.getcwd()
+    template_dir = templates.gui_template()
+
+    root_files = ['package.json', 'Dockerfile', 'vite.config.mts', '.yarnrc.yml']
+
+    conflicting_files = []
+    files_to_overwrite = set()
+
+    for root, _, filenames in os.walk(template_dir):
+        relative_dir = os.path.relpath(root, template_dir)
+
+        for filename in filenames:
+            if filename in root_files:
+                destination_dir = cwd
+            else:
+                if relative_dir == '.':
+                    destination_dir = os.path.join(cwd, 'gui')
+                else:
+                    destination_dir = os.path.join(cwd, 'gui', relative_dir)
+
+            source_file = os.path.join(root, filename)
+            destination_file = os.path.join(destination_dir, filename)
+
+            if filename == 'Dockerfile':
+                continue
+
+            if os.path.exists(destination_file) and not force:
+                with open(source_file, 'rb') as fsrc, open(destination_file, 'rb') as fdest:
+                    if fsrc.read() != fdest.read():
+                        conflicting_files.append(os.path.relpath(destination_file, cwd))
+
+    if conflicting_files:
+        print('The following files already exist and would be overwritten:')
+        for conflicting_file in conflicting_files:
+            print(f'  {conflicting_file}')
+        print()
+
+        for conflicting_file in conflicting_files:
+            choice = input(f'Overwrite {conflicting_file}? [y/N]: ').lower().strip()
+            if choice in ['y', 'yes']:
+                files_to_overwrite.add(conflicting_file)
+
+    for root, _, filenames in os.walk(template_dir):
+        relative_dir = os.path.relpath(root, template_dir)
+
+        for filename in filenames:
+            if filename in root_files:
+                destination_dir = cwd
+            else:
+                if relative_dir == '.':
+                    destination_dir = os.path.join(cwd, 'gui')
+                else:
+                    destination_dir = os.path.join(cwd, 'gui', relative_dir)
+
+            source_file = os.path.join(root, filename)
+            destination_file = os.path.join(destination_dir, filename)
+            relative_file_path = os.path.relpath(destination_file, cwd)
+
+            should_force = force or filename == 'Dockerfile'
+            if not os.path.exists(destination_file) or should_force or relative_file_path in files_to_overwrite:
+                os.makedirs(destination_dir, exist_ok=True)
+                shutil.copy2(source_file, destination_file)
+
+    gitignore_path = os.path.join(cwd, '.gitignore')
+    with open(gitignore_path, 'a') as gitignore_file:
+        gitignore_file.write('\n# gui\n')
+        gitignore_file.write('.yarn\n')
+        gitignore_file.write('dist\n')
+        gitignore_file.write('yarn.lock\n')
+        gitignore_file.write('tsconfig.tsbuildinfo\n')
+        gitignore_file.write('node_modules\n')
+
+    if not silent:
+        print('gui files added to project root and gui/ subdirectory')

biolib/_internal/data_record/__init__.py

@@ -1 +1 @@
-from .data_record import get_data_record_state_from_uri, validate_sqlite_v1
+from .data_record import validate_sqlite_v1

biolib/_internal/data_record/data_record.py

@@ -1,11 +1,7 @@
 import sqlite3
 from pathlib import Path
 
-from biolib._internal.types.data_record import SqliteV1DatabaseSchema
-from biolib.api import client as api_client
-from biolib.biolib_api_client import AppGetResponse
-from biolib.biolib_api_client.biolib_app_api import _get_app_uri_from_str
-from biolib.biolib_api_client.lfs_types import DataRecordVersionInfo
+from biolib._shared.types import SqliteV1DatabaseSchema
 
 
 def get_actual_schema(db_path):
@@ -82,19 +78,6 @@ def verify_schema(specification: SqliteV1DatabaseSchema, actual_schema: SqliteV1
                     )
 
 
-def get_data_record_state_from_uri(uri) -> 'DataRecordVersionInfo':
-    normalized_uri = _get_app_uri_from_str(uri)
-    app_response: AppGetResponse = api_client.get(path='/app/', params={'uri': normalized_uri}).json()
-    resource_uri = app_response['app_version']['app_uri']
-    if app_response['app']['type'] != 'data-record':
-        raise Exception(f'Resource "{resource_uri}" is not a Data Record')
-    return DataRecordVersionInfo(
-        resource_uri=app_response['app_version']['app_uri'],
-        resource_uuid=app_response['app']['public_id'],
-        resource_version_uuid=app_response['app_version']['public_id'],
-    )
-
-
 def validate_sqlite_v1(schema: SqliteV1DatabaseSchema, sqlite_file: Path):
     actual_schema = get_actual_schema(sqlite_file)
     print(schema)

biolib/_internal/data_record/push_data.py

@@ -1,10 +1,58 @@
+from __future__ import annotations
+
 import os
+from typing import Callable, Iterator
 
-from biolib import utils
+import biolib.api as api
 from biolib._internal.file_utils import get_files_and_size_of_directory, get_iterable_zip_stream
-from biolib._internal.types.typing import List, Optional, Tuple
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger
+from biolib.typing_utils import List, Optional, Tuple
+from biolib.utils import MultiPartUploader
+
+
+def _upload_from_iterator(
+    payload_iterator: Iterator[bytes],
+    payload_size_in_bytes: int,
+    resource_uuid: Optional[str] = None,
+    resource_version_uuid: Optional[str] = None,
+    use_process_pool: bool = False,
+    publish: bool = False,
+    on_progress: Optional[Callable[[int, int], None]] = None,
+) -> str:
+    if (resource_uuid is None) == (resource_version_uuid is None):
+        raise ValueError('Must provide exactly one of resource_uuid or resource_version_uuid')
+
+    if resource_version_uuid is None:
+        response = api.client.post(
+            path='/lfs/versions/',
+            data={'resource_uuid': resource_uuid},
+        )
+        resource_version_uuid = response.json()['uuid']
+
+    multipart_uploader = MultiPartUploader(
+        use_process_pool=use_process_pool,
+        get_presigned_upload_url_request={
+            'headers': None,
+            'requires_biolib_auth': True,
+            'path': f'/lfs/versions/{resource_version_uuid}/presigned_upload_url/',
+        },
+        complete_upload_request={
+            'headers': None,
+            'requires_biolib_auth': True,
+            'path': f'/lfs/versions/{resource_version_uuid}/complete_upload/',
+        },
+        on_progress=on_progress,
+    )
+    multipart_uploader.upload(payload_iterator=payload_iterator, payload_size_in_bytes=payload_size_in_bytes)
+
+    if publish:
+        api.client.patch(
+            path=f'/resources/versions/{resource_version_uuid}/',
+            data={'state': 'published', 'set_as_active': True},
+        )
+
+    return resource_version_uuid
 
 
 def validate_data_path_and_get_files_and_size_of_directory(data_path: str) -> Tuple[List[str], int]:
@@ -28,9 +76,14 @@ def push_data_path(
     data_path: str,
     data_size_in_bytes: int,
     files_to_zip: List[str],
-    resource_version_uuid: str,
+    resource_uuid: Optional[str] = None,
+    resource_version_uuid: Optional[str] = None,
     chunk_size_in_mb: Optional[int] = None,
-) -> None:
+    publish: bool = False,
+) -> str:
+    if (resource_uuid is None) == (resource_version_uuid is None):
+        raise ValueError('Must provide exactly one of resource_uuid or resource_version_uuid')
+
     original_working_dir = os.getcwd()
     os.chdir(data_path)
 
@@ -49,19 +102,15 @@ def push_data_path(
     logger.info(f'Zipping {len(files_to_zip)} files, in total ~{data_size_in_mb}mb of data')
 
     iterable_zip_stream = get_iterable_zip_stream(files=files_to_zip, chunk_size=chunk_size_in_bytes)
-    multipart_uploader = utils.MultiPartUploader(
+
+    new_resource_version_uuid = _upload_from_iterator(
+        payload_iterator=iterable_zip_stream,
+        payload_size_in_bytes=data_size_in_bytes,
+        resource_uuid=resource_uuid,
+        resource_version_uuid=resource_version_uuid,
         use_process_pool=True,
-        get_presigned_upload_url_request=dict(
-            headers=None,
-            requires_biolib_auth=True,
-            path=f'/lfs/versions/{resource_version_uuid}/presigned_upload_url/',
-        ),
-        complete_upload_request=dict(
-            headers=None,
-            requires_biolib_auth=True,
-            path=f'/lfs/versions/{resource_version_uuid}/complete_upload/',
-        ),
+        publish=publish,
     )
 
-    multipart_uploader.upload(payload_iterator=iterable_zip_stream, payload_size_in_bytes=data_size_in_bytes)
     os.chdir(original_working_dir)
+    return new_resource_version_uuid

biolib/_internal/data_record/remote_storage_endpoint.py

@@ -1,38 +1,43 @@
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from urllib.parse import urlparse
 
+from biolib._shared.types import ResourceDetailedDict
 from biolib.api import client as api_client
-from biolib.biolib_api_client.lfs_types import DataRecordVersion
 from biolib.biolib_binary_format.utils import RemoteEndpoint
 from biolib.biolib_logging import logger
 from biolib.typing_utils import Optional
 
 
 class DataRecordRemoteStorageEndpoint(RemoteEndpoint):
-    def __init__(self, resource_version_uuid: str):
-        self._resource_version_uuid: str = resource_version_uuid
+    def __init__(self, uri: str):
+        self._uri: str = uri
         self._expires_at: Optional[datetime] = None
         self._presigned_url: Optional[str] = None
 
     def get_remote_url(self) -> str:
-        if not self._presigned_url or not self._expires_at or datetime.utcnow() > self._expires_at:
-            lfs_version: DataRecordVersion = api_client.get(
-                path=f'/lfs/versions/{self._resource_version_uuid}/',
+        if not self._presigned_url or not self._expires_at or datetime.now(timezone.utc) > self._expires_at:
+            resource_response: ResourceDetailedDict = api_client.get(
+                path='/resource/',
+                params={'uri': self._uri},
             ).json()
 
+            version = resource_response.get('version')
+            assets = version.get('assets') if version else None
+            if not assets:
+                raise Exception(f'Resource "{self._uri}" has no downloadable assets')
+
+            download_url = assets['download_url']
             app_caller_proxy_job_storage_base_url = os.getenv('BIOLIB_CLOUD_JOB_STORAGE_BASE_URL', '')
             if app_caller_proxy_job_storage_base_url:
-                # Done to hit App Caller Proxy when downloading from inside an app
-                parsed_url = urlparse(lfs_version['presigned_download_url'])
+                parsed_url = urlparse(download_url)
                 self._presigned_url = f'{app_caller_proxy_job_storage_base_url}{parsed_url.path}?{parsed_url.query}'
             else:
-                self._presigned_url = lfs_version['presigned_download_url']
+                self._presigned_url = download_url
 
-            self._expires_at = datetime.utcnow() + timedelta(minutes=8)
+            self._expires_at = datetime.now(timezone.utc) + timedelta(minutes=8)
             logger.debug(
-                f'DataRecord "{self._resource_version_uuid}" fetched presigned URL '
-                f'with expiry at {self._expires_at.isoformat()}'
+                f'DataRecord "{self._uri}" fetched presigned URL ' f'with expiry at {self._expires_at.isoformat()}'
             )
 
         return self._presigned_url

biolib/_internal/file_utils.py

@@ -1,5 +1,7 @@
+import hashlib
 import io
 import os
+import posixpath
 import zipfile as zf
 from pathlib import Path
 
@@ -75,3 +77,49 @@ def get_iterable_zip_stream(files: List[str], chunk_size: int) -> Iterator[bytes
         if len(chunk) == 0:
             break
         yield chunk
+
+
+def path_to_renamed_path(path_str: str, prefix_with_slash: bool = True) -> str:
+    """
+    Normalize file paths consistently:
+    - If path contains '..' (relative path going up), convert to absolute path
+    - If relative path not containing '..', keep as is, but prepend / if prefix_with_slash=True
+    - If absolute path that is subpath of current directory, convert to relative path
+    - If absolute path not subpath of current directory, hash the folder path and keep filename
+    """
+    path = Path(path_str)
+    current_dir = Path.cwd()
+
+    if '..' in path.parts:
+        resolved_path = path.resolve()
+        try:
+            relative_path = resolved_path.relative_to(current_dir)
+            result = str(relative_path)
+        except ValueError:
+            folder_path = str(resolved_path.parent)
+            filename = resolved_path.name
+            folder_hash = hashlib.md5(folder_path.encode()).hexdigest()[:6]
+            result = f'/{folder_hash}/{filename}'
+    elif path.is_absolute():
+        try:
+            resolved_path = path.resolve()
+            relative_path = resolved_path.relative_to(current_dir)
+            result = str(relative_path)
+        except ValueError:
+            folder_path = str(path.parent)
+            filename = path.name
+            folder_hash = hashlib.md5(folder_path.encode()).hexdigest()[:6]
+            result = f'/{folder_hash}/{filename}'
+    else:
+        result = path_str
+
+    if prefix_with_slash:
+        if not result.startswith('/'):
+            result = '/' + result
+        # Normalize to handle cases like '/./mydir' -> '/mydir' and remove trailing slashes.
+        # Required because downstream Mappings class does exact string-prefix matching.
+        return posixpath.normpath(result)
+    else:
+        if result.startswith('/'):
+            result = result[1:]
+        return posixpath.normpath(result)

biolib/_internal/lfs/cache.py

@@ -1,6 +1,6 @@
 import os
 import subprocess
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from biolib.biolib_logging import logger_no_user_data
 from biolib.compute_node.job_worker.cache_state import LfsCacheState
@@ -9,7 +9,7 @@ from biolib.compute_node.job_worker.cache_state import LfsCacheState
 def prune_lfs_cache(dry_run: bool) -> None:
     logger_no_user_data.info(f'Pruning LFS cache (dry run = {dry_run})...')
 
-    current_time = datetime.utcnow()
+    current_time = datetime.now(timezone.utc)
     paths_to_delete = set()
 
     with LfsCacheState() as state:
@@ -24,6 +24,8 @@ def prune_lfs_cache(dry_run: bool) -> None:
         lfs_uuids_to_keep_in_state = set()
         for lfs_uuid, lfs in state['large_file_systems'].items():
             last_used_at = datetime.fromisoformat(lfs['last_used_at'])
+            if last_used_at.tzinfo is None:
+                last_used_at = last_used_at.replace(tzinfo=timezone.utc)
             lfs_time_to_live_in_days = 60 if lfs['state'] == 'ready' else 7
 
             if last_used_at < current_time - timedelta(days=lfs_time_to_live_in_days):

biolib/_internal/push_application.py

@@ -1,3 +1,4 @@
+import json
 import os
 import re
 import sys
@@ -14,14 +15,14 @@ from biolib._internal.data_record.push_data import (
 )
 from biolib._internal.errors import AuthenticationError
 from biolib._internal.file_utils import get_files_and_size_of_directory, get_iterable_zip_stream
-from biolib._internal.types.push import PushResponseDict
+from biolib._shared.types import PushResponseDict
+from biolib._shared.utils import parse_resource_uri
 from biolib.biolib_api_client import BiolibApiClient
 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.typing_utils import Iterable, Optional, Set, TypedDict
-from biolib.utils.app_uri import parse_app_uri
+from biolib.typing_utils import Dict, Iterable, Optional, Set, TypedDict, Union
 
 REGEX_MARKDOWN_INLINE_IMAGE = re.compile(r'!\[(?P<alt>.*)\]\((?P<src>.*)\)')
 
@@ -108,8 +109,10 @@ def _process_docker_status_updates_with_progress_bar(status_updates: Iterable[Do
 
 
 def _process_docker_status_updates_with_logging(status_updates: Iterable[DockerStatusUpdate], action: str) -> None:
-    layer_progress = {}
-    layer_status = {}
+    layer_progress: Dict[str, float] = {}
+    layer_status: Dict[str, str] = {}
+    layer_details: Dict[str, Dict[str, int]] = {}
+    layer_bytes_at_last_log: Dict[str, int] = {}
     last_log_time = time.time()
 
     logger.info(f'{action} Docker image...')
@@ -127,6 +130,7 @@ def _process_docker_status_updates_with_logging(status_updates: Iterable[DockerS
                 percentage = (current / total * 100) if total > 0 else 0
                 layer_progress[layer_id] = percentage
                 layer_status[layer_id] = f'{action.lower()}'
+                layer_details[layer_id] = {'current': current, 'total': total}
             elif update.get('status') == 'Layer already exists':
                 layer_progress[layer_id] = 100
                 layer_status[layer_id] = 'already exists'
@@ -145,14 +149,33 @@ def _process_docker_status_updates_with_logging(status_updates: Iterable[DockerS
                 logger.info(f'{action} Docker image - {status}')
 
         if current_time - last_log_time >= 10.0:
-            _log_progress_summary(action, layer_progress, layer_status)
+            _log_progress_summary(
+                action,
+                layer_progress,
+                layer_status,
+                layer_details,
+                layer_bytes_at_last_log,
+                current_time - last_log_time,
+            )
+            layer_bytes_at_last_log = {lid: details['current'] for lid, details in layer_details.items()}
             last_log_time = current_time
 
-    _log_progress_summary(action, layer_progress, layer_status)
+    _log_progress_summary(
+        action, layer_progress, layer_status, layer_details, layer_bytes_at_last_log, time.time() - last_log_time
+    )
+    if action == 'Pushing':
+        logger.info('Pushing final image manifest...')
     logger.info(f'{action} Docker image completed')
 
 
-def _log_progress_summary(action: str, layer_progress: dict, layer_status: dict) -> None:
+def _log_progress_summary(
+    action: str,
+    layer_progress: Dict[str, float],
+    layer_status: Dict[str, str],
+    layer_details: Dict[str, Dict[str, int]],
+    layer_bytes_at_last_log: Dict[str, int],
+    time_delta: float,
+) -> None:
     if not layer_progress and not layer_status:
         return
 
@@ -171,7 +194,36 @@ def _log_progress_summary(action: str, layer_progress: dict, layer_status: dict)
         if status in ['preparing', 'waiting', 'pushing', 'uploading'] and layer_progress.get(layer_id, 0) < 100
     ]
 
-    if active_layers:
+    if active_layers and layer_details:
+        total_bytes_transferred = 0
+        layer_info_parts = []
+
+        for layer_id in active_layers[:5]:
+            if layer_id in layer_details:
+                details = layer_details[layer_id]
+                current = details['current']
+                total = details['total']
+                percentage = layer_progress.get(layer_id, 0)
+
+                bytes_since_last = current - layer_bytes_at_last_log.get(layer_id, 0)
+                total_bytes_transferred += bytes_since_last
+
+                current_mb = current / (1024 * 1024)
+                total_mb = total / (1024 * 1024)
+                layer_info_parts.append(f'{layer_id}: {current_mb:.1f}/{total_mb:.1f} MB ({percentage:.1f}%)')
+
+        speed_info = ''
+        if time_delta > 0 and total_bytes_transferred > 0:
+            speed_mbps = (total_bytes_transferred / (1024 * 1024)) / time_delta
+            speed_info = f' @ {speed_mbps:.2f} MB/s'
+
+        more_layers_info = ''
+        if len(active_layers) > 5:
+            more_layers_info = f' (+ {len(active_layers) - 5} more)'
+
+        if layer_info_parts:
+            logger.info(f'Active layers: {", ".join(layer_info_parts)}{speed_info}{more_layers_info}')
+    elif active_layers:
         logger.info(f'Active layers: {", ".join(active_layers[:5])}{"..." if len(active_layers) > 5 else ""}')
 
 
@@ -193,10 +245,12 @@ def push_application(
     set_as_published: bool,
     dry_run: bool = False,
 ) -> Optional[PushResponseDict]:
-    parsed_uri = parse_app_uri(app_uri)
-    app_name = parsed_uri['app_name']
+    app_uri = app_uri.rstrip('/')
+    parsed_uri = parse_resource_uri(app_uri)
+    resource_name = parsed_uri['resource_name']
 
-    app_uri_to_fetch = f"@{parsed_uri['resource_name_prefix']}/{parsed_uri['account_handle_normalized']}/{app_name}"
+    app_uri_prefix = f"@{parsed_uri['resource_prefix']}/" if parsed_uri['resource_prefix'] is not None else ''
+    app_uri_to_fetch = f"{app_uri_prefix}{parsed_uri['account_handle_normalized']}/{resource_name}"
 
     version = parsed_uri['version']
     semantic_version = f"{version['major']}.{version['minor']}.{version['patch']}" if version else None
@@ -205,14 +259,14 @@ def push_application(
 
     api_client = BiolibApiClient.get()
     if not api_client.is_signed_in:
-        github_ref = os.getenv('GITHUB_REF')
-        if github_ref and not api_client.resource_deploy_key:
+        github_repository = os.getenv('GITHUB_REPOSITORY')
+        if github_repository and not api_client.resource_deploy_key:
+            github_secrets_url = f'https://github.com/{github_repository}/settings/secrets/actions/new'
             raise AuthenticationError(
                 'You must be authenticated to push an application.\n'
                 'Please set the environment variable "BIOLIB_TOKEN=[your_deploy_token]"\n'
                 f'You can get a deploy key at: {api_client.base_url}/{app_uri_to_fetch}/settings/keys/\n'
-                'Then add it to your GitHub repository at: '
-                'Settings -> Secrets and variables -> Actions -> Repository secrets'
+                f'Then add it to your GitHub repository at: {github_secrets_url}'
             )
         else:
             raise AuthenticationError(
@@ -233,19 +287,34 @@ def push_application(
     app_data_path: Optional[Path] = None
     try:
         with open(config_yml_path) as config_yml_file:
-            config = yaml.safe_load(config_yml_file.read())
+            try:
+                config = json.loads(json.dumps(yaml.safe_load(config_yml_file.read())))
+            except (TypeError, ValueError) as e:
+                raise BioLibError(
+                    f'The .biolib/config.yml file contains data types that are not supported '
+                    f'(must be JSON-serializable). Please ensure only standard JSON types '
+                    f'(str, int, float, bool, list, dict, null) are used. Original error: {e}'
+                ) from e
+
+        if 'assets' in config and 'app_data' not in config:
+            config['app_data'] = config.pop('assets')
+        elif 'assets' in config and 'app_data' in config:
+            raise BioLibError(
+                'In .biolib/config.yml you cannot specify both "app_data" and "assets" fields. Please use only one.'
+            )
 
         app_data = config.get('app_data')
         if app_data:
+            field_name = 'app_data' if 'app_data' in config else 'assets'
             if not isinstance(app_data, str):
                 raise BioLibError(
-                    f'In .biolib/config.yml the value of "app_data" must be a string but got {type(app_data)}'
+                    f'In .biolib/config.yml the value of "{field_name}" must be a string but got {type(app_data)}'
                 )
 
             app_data_path = app_path_absolute.joinpath(app_data).resolve()
             if not app_data_path.is_dir():
                 raise BioLibError(
-                    'In .biolib/config.yml the value of "app_data" must be a path to a directory '
+                    f'In .biolib/config.yml the value of "{field_name}" must be a path to a directory '
                     'in the application directory'
                 )
 
@@ -316,10 +385,6 @@ def push_application(
     app_response = BiolibAppApi.get_by_uri(app_uri_to_fetch)
     app = app_response['app']
 
-    if app_data and not app['allow_client_side_execution']:
-        raise BioLibError(
-            'To push a version with app_data the app must be set to "Allow Client-Side Source Code Access"'
-        )
     if dry_run:
         logger.info('Successfully completed dry-run. No new version was pushed.')
         return None
@@ -405,9 +470,15 @@ def push_application(
             logger.info(f'Successfully pushed {docker_image_name}')
 
     app_version_uuid = new_app_version_json['public_id']
+    complete_push_data: Dict[str, Union[bool, str]] = {
+        'set_as_active': set_as_active,
+        'set_as_published': set_as_published,
+    }
+    if parsed_uri['tag']:
+        complete_push_data['tag'] = parsed_uri['tag']
     api.client.post(
         path=f'/app-versions/{app_version_uuid}/complete-push/',
-        data={'set_as_active': set_as_active, 'set_as_published': set_as_published},
+        data=complete_push_data,
     )
 
     sematic_version = f"{new_app_version_json['major']}.{new_app_version_json['minor']}.{new_app_version_json['patch']}"

biolib/_internal/runtime.py

@@ -4,10 +4,12 @@ from biolib.typing_utils import TypedDict
 class RuntimeJobDataDict(TypedDict):
     version: str
     job_requested_machine: str
+    job_requested_machine_spot: bool
     job_uuid: str
     job_auth_token: str
     app_uri: str
     is_environment_biolib_cloud: bool
+    job_reserved_machines: int
 
 
 class BioLibRuntimeError(Exception):