pybiolib 1.2.1056__py3-none-any.whl → 1.2.1642__py3-none-any.whl

biolib/__init__.py

@@ -1,3 +1,4 @@
+# ruff: noqa: I001
 # Imports to hide
 import os
 from urllib.parse import urlparse as _urlparse
@@ -15,6 +16,7 @@ from biolib.jobs.job import Result as _Result
 from biolib import user as _user
 from biolib.typing_utils import List, Optional, cast as _cast
 from biolib._data_record.data_record import DataRecord as _DataRecord
+from biolib._internal.utils.job_url import parse_result_id_or_url as _parse_result_id_or_url
 
 import biolib.api
 import biolib.app
@@ -22,7 +24,6 @@ import biolib.cli
 import biolib.sdk
 import biolib.utils
 
-
 # ------------------------------------ Function definitions for public Python API ------------------------------------
 
 
@@ -83,43 +84,65 @@ def search(
 
 
 def get_job(job_id: str, job_token: Optional[str] = None) -> _Result:
-    r"""Get a job by its ID.
+    r"""Get a job by its ID or full URL.
 
     Args:
-        job_id (str): The UUID of the job to retrieve
+        job_id (str): The UUID of the job to retrieve, or a full URL to the job.
+            Can be either:
+            - Job UUID (e.g., 'abc123')
+            - Full URL (e.g., 'https://biolib.com/result/abc123/?token=xyz789')
+            - Full URL with token parameter (e.g., 'biolib.com/result/abc123/token=xyz789')
         job_token (str, optional): Authentication token for accessing the job.
             Only needed for jobs that aren't owned by the current user.
+            If the URL contains a token, this parameter is ignored.
 
     Returns:
         Job: The job object
 
     Example::
 
+        >>> # Get by UUID
         >>> job = biolib.get_job('abc123')
-        >>> # Access shared job
+        >>> # Get with explicit token
         >>> job = biolib.get_job('abc123', job_token='xyz789')
+        >>> # Get by full URL with token
+        >>> job = biolib.get_job('https://biolib.com/result/abc123/?token=xyz789')
+        >>> # Get by URL with inline token format
+        >>> job = biolib.get_job('biolib.com/result/abc123/token=xyz789')
     """
-    return _Result.create_from_uuid(uuid=job_id, auth_token=job_token)
+    uuid, token = _parse_result_id_or_url(job_id, job_token)
+    return _Result.create_from_uuid(uuid=uuid, auth_token=token)
 
 
 def get_result(result_id: str, result_token: Optional[str] = None) -> _Result:
-    r"""Get a result by its ID.
+    r"""Get a result by its ID or full URL.
 
     Args:
-        result_id (str): The UUID of the result to retrieve
+        result_id (str): The UUID of the result to retrieve, or a full URL to the result.
+            Can be either:
+            - Result UUID (e.g., 'abc123')
+            - Full URL (e.g., 'https://biolib.com/result/abc123/?token=xyz789')
+            - Full URL with token parameter (e.g., 'biolib.com/result/abc123/token=xyz789')
         result_token (str, optional): Authentication token for accessing the result.
-            Only needed for result that aren't owned by the current user.
+            Only needed for results that aren't owned by the current user.
+            If the URL contains a token, this parameter is ignored.
 
     Returns:
         Result: The result object
 
     Example::
 
+        >>> # Get by UUID
         >>> result = biolib.get_result('abc123')
-        >>> # Access shared result
+        >>> # Get with explicit token
         >>> result = biolib.get_result('abc123', result_token='xyz789')
+        >>> # Get by full URL with token
+        >>> result = biolib.get_result('https://biolib.com/result/abc123/?token=xyz789')
+        >>> # Get by URL with inline token format
+        >>> result = biolib.get_result('biolib.com/result/abc123/token=xyz789')
     """
-    return _Result.create_from_uuid(uuid=result_id, auth_token=result_token)
+    uuid, token = _parse_result_id_or_url(result_id, result_token)
+    return _Result.create_from_uuid(uuid=uuid, auth_token=token)
 
 
 def get_data_record(uri: str) -> _DataRecord:

biolib/_data_record/data_record.py

@@ -6,7 +6,6 @@ from struct import Struct
 from typing import Callable, Dict, Iterable, List, Optional, Union, cast
 
 from biolib import api
-from biolib._internal import types
 from biolib._internal.data_record import get_data_record_state_from_uri
 from biolib._internal.data_record.data_record import validate_sqlite_v1
 from biolib._internal.data_record.push_data import (
@@ -15,14 +14,15 @@ from biolib._internal.data_record.push_data import (
 )
 from biolib._internal.data_record.remote_storage_endpoint import DataRecordRemoteStorageEndpoint
 from biolib._internal.http_client import HttpClient
-from biolib._internal.types.file_node import ZipFileNodeDict
+from biolib._shared import types
+from biolib._shared.types import ZipFileNodeDict
+from biolib._shared.utils import parse_resource_uri
 from biolib.api import client as api_client
 from biolib.biolib_api_client import BiolibApiClient
 from biolib.biolib_api_client.lfs_types import DataRecordInfo, DataRecordVersion, DataRecordVersionInfo
 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
 
 PathFilter = Union[str, List[str], Callable[[str], bool]]
 
@@ -44,11 +44,11 @@ class DataRecord:
 
     @property
     def name(self) -> str:
-        uri_parsed = parse_app_uri(self._state['resource_uri'], use_account_as_name_default=False)
-        if not uri_parsed['app_name']:
+        uri_parsed = parse_resource_uri(self._state['resource_uri'], use_account_as_name_default=False)
+        if not uri_parsed['resource_name']:
             raise ValueError('Expected parameter "resource_uri" to contain resource name')
 
-        return uri_parsed['app_name']
+        return uri_parsed['resource_name']
 
     def list_files(
         self,
@@ -142,8 +142,8 @@ class DataRecord:
         BiolibApiClient.assert_is_signed_in(authenticated_action_description='create a Data Record')
         if data_path is not None:
             assert os.path.isdir(data_path), f'The path "{data_path}" is not a directory.'
-        uri_parsed = parse_app_uri(destination, use_account_as_name_default=False)
-        if uri_parsed['app_name_normalized']:
+        uri_parsed = parse_resource_uri(destination, use_account_as_name_default=False)
+        if uri_parsed['resource_name_normalized']:
             data_record_uri = destination
         else:
             record_name = 'data-record-' + datetime.now().isoformat().split('.')[0].replace(':', '-')
@@ -173,10 +173,10 @@ class DataRecord:
             'resource_type': 'data-record',
         }
         if uri:
-            uri_parsed = parse_app_uri(uri, use_account_as_name_default=False)
+            uri_parsed = parse_resource_uri(uri, use_account_as_name_default=False)
             params['account_handle'] = uri_parsed['account_handle_normalized']
-            if uri_parsed['app_name_normalized']:
-                params['app_name'] = uri_parsed['app_name_normalized']
+            if uri_parsed['resource_name_normalized']:
+                params['app_name'] = uri_parsed['resource_name_normalized']
 
         results = api_client.get(path='/apps/', params=params).json()['results']
         if count is None and len(results) == max_page_size:
@@ -284,3 +284,16 @@ class DataRecord:
 
     def _get_detailed_dict(self) -> types.DataRecordDetailedDict:
         return cast(types.DataRecordDetailedDict, api_client.get(f'/resources/data-records/{self.uuid}/').json())
+
+    def delete(self) -> None:
+        """Delete the data record.
+
+        Example::
+            >>> record = DataRecord.get_by_uri("account/data-record")
+            >>> record.delete()
+        """
+        try:
+            api_client.delete(path=f'/apps/{self.uuid}/')
+            logger.info(f'Data record {self.uri} deleted')
+        except Exception as error:
+            raise Exception(f'Failed to delete data record {self.uri} due to: {error}') from error

biolib/_index/index.py

@@ -0,0 +1,51 @@
+import json
+from typing import Any, Dict
+
+from biolib import api
+from biolib._index.types import IndexInfo
+from biolib._internal.index import get_index_from_uri
+from biolib.biolib_api_client import BiolibApiClient
+from biolib.biolib_logging import logger
+
+
+class Index:
+    def __init__(self, _internal_state: IndexInfo):
+        self._state = _internal_state
+
+    def __repr__(self) -> str:
+        return f'Index: {self._state["resource_uri"]}'
+
+    @property
+    def uri(self) -> str:
+        return self._state['resource_uri']
+
+    @property
+    def id(self) -> str:
+        return f"{self._state['group_uuid']}.{self._state['resource_uuid']}".replace("-", "_")
+
+    @staticmethod
+    def get_by_uri(uri: str) -> 'Index':
+        return Index(_internal_state=get_index_from_uri(uri))
+
+    @staticmethod
+    def create(uri: str, config: Dict[str, Any]) -> str:
+        BiolibApiClient.assert_is_signed_in(authenticated_action_description='create an Index')
+
+        response = api.client.post(
+            path='/resources/indexes/',
+            data={
+                'uri': uri,
+                'index_config': config,
+            },
+        )
+        result = response.json()
+        created_uri: str = result['uri']
+        logger.info(f"Successfully created Index '{created_uri}'")
+        return created_uri
+
+    @staticmethod
+    def create_from_config_file(uri: str, config_path: str) -> str:
+        with open(config_path) as config_file:
+            index_config = json.load(config_file)
+
+        return Index.create(uri=uri, config=index_config)

biolib/_index/types.py

@@ -0,0 +1,7 @@
+from typing import TypedDict
+
+
+class IndexInfo(TypedDict):
+    resource_uri: str
+    resource_uuid: str
+    group_uuid: str

biolib/_internal/data_record/data_record.py

@@ -1,7 +1,7 @@
 import sqlite3
 from pathlib import Path
 
-from biolib._internal.types.data_record import SqliteV1DatabaseSchema
+from biolib._shared.types 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

biolib/_internal/data_record/push_data.py

@@ -2,9 +2,9 @@ import os
 
 from biolib import utils
 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
 
 
 def validate_data_path_and_get_files_and_size_of_directory(data_path: str) -> Tuple[List[str], int]:

biolib/_internal/data_record/remote_storage_endpoint.py

@@ -1,5 +1,5 @@
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from urllib.parse import urlparse
 
 from biolib.api import client as api_client
@@ -16,7 +16,7 @@ class DataRecordRemoteStorageEndpoint(RemoteEndpoint):
         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:
+        if not self._presigned_url or not self._expires_at or datetime.now(timezone.utc) > self._expires_at:
             lfs_version: DataRecordVersion = api_client.get(
                 path=f'/lfs/versions/{self._resource_version_uuid}/',
             ).json()
@@ -29,7 +29,7 @@ class DataRecordRemoteStorageEndpoint(RemoteEndpoint):
             else:
                 self._presigned_url = lfs_version['presigned_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()}'

biolib/_internal/file_utils.py

@@ -1,6 +1,7 @@
 import hashlib
 import io
 import os
+import posixpath
 import zipfile as zf
 from pathlib import Path
 
@@ -114,9 +115,11 @@ def path_to_renamed_path(path_str: str, prefix_with_slash: bool = True) -> str:
 
     if prefix_with_slash:
         if not result.startswith('/'):
-            return '/' + result
-        return result
+            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('/'):
-            return result[1:]
-        return result
+            result = result[1:]
+        return posixpath.normpath(result)

biolib/_internal/index/__init__.py

@@ -0,0 +1 @@
+from .index import get_index_from_uri

biolib/_internal/index/index.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict
+
+from biolib._index.types import IndexInfo
+from biolib.api import client as api_client
+from biolib.biolib_api_client.biolib_app_api import _get_app_uri_from_str
+
+
+def get_index_from_uri(uri: str) -> IndexInfo:
+    normalized_uri = _get_app_uri_from_str(uri)
+    app_response: Dict[str, Any] = api_client.get(path='/app/', params={'uri': normalized_uri}).json()
+    resource_uri = app_response['app_version']['app_uri']
+    if app_response['app']['type'] != 'index':
+        raise Exception(f'Resource "{resource_uri}" is not an Index')
+    return IndexInfo(
+        resource_uri=app_response['app_version']['app_uri'],
+        resource_uuid=app_response['app']['public_id'],
+        group_uuid=app_response['app']['group_uuid'],
+    )

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,16 +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
 
@@ -173,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 ""}')
 
 
@@ -195,13 +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_prefix = (
-        f"@{parsed_uri['resource_name_prefix']}/" if parsed_uri['resource_name_prefix'] != 'biolib.com' else ''
-    )
-    app_uri_to_fetch = f"{app_uri_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
@@ -238,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'
                 )
 
@@ -321,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
@@ -410,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):

biolib/_internal/templates/gui_template/App.tsx

@@ -1,16 +1,52 @@
+import { useState, useEffect } from "react";
+import biolib from "./biolib-sdk";
+
 export default function App() {
+  const [outputFileData, setOutputFileData] = useState<Uint8Array | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  const loadOutputData = async () => {
+    setLoading(true);
+    try {
+      const data = await biolib.getOutputFileData("output.json");
+      setOutputFileData(data);
+    } catch (error) {
+      console.error("Error loading output data:", error);
+      setOutputFileData(null);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    loadOutputData();
+  }, []);
+
   return (
     <div className="min-h-screen bg-gray-100 flex items-center justify-center">
-      <div className="text-center">
+      <div className="text-center max-w-2xl mx-auto p-8">
         <h1 className="text-4xl font-bold mb-4">
           Hello, BioLib!
         </h1>
         <p className="text-lg mb-2">
           You have successfully set up your BioLib GUI application.
         </p>
-        <p className="italic">
+        <p className="italic mb-6">
           This is a simple React template with Tailwind CSS styling.
         </p>
+
+        <div className="mt-8 p-4 bg-white rounded-lg shadow">
+          <h2 className="text-xl font-semibold mb-4">Example: Reading Output Files</h2>
+          {loading ? (
+            <p className="text-gray-500">Loading output.json...</p>
+          ) : outputFileData ? (
+            <div className="p-3 bg-gray-50 rounded text-left">
+              <pre className="text-sm">{new TextDecoder().decode(outputFileData)}</pre>
+            </div>
+          ) : (
+            <p className="text-red-500">Failed to load output.json</p>
+          )}
+        </div>
       </div>
     </div>
   );

biolib/_internal/templates/gui_template/Dockerfile

@@ -1,3 +1,5 @@
+# syntax=docker/dockerfile:1
+
 FROM node:24.4.1-alpine3.21 AS gui_builder
 
 WORKDIR /home/biolib/