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

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/

biolib/_internal/templates/gui_template/biolib-sdk.ts

@@ -0,0 +1,37 @@
+interface IBioLibGlobals {
+  getOutputFileData: (path: string) => Promise<Uint8Array>;
+}
+
+declare global {
+  const biolib: IBioLibGlobals;
+}
+
+// DO NOT MODIFY: Development data files are injected at build time from gui/dev-data/ folder
+const DEV_DATA_FILES: Record<string, string> = {};
+
+const devSdkBioLib: IBioLibGlobals = {
+  getOutputFileData: async (path: string): Promise<Uint8Array> => {
+    console.log(`[SDK] getOutputFileData called with path: ${path}`);
+    
+    const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
+    
+    if (typeof DEV_DATA_FILES !== 'undefined' && normalizedPath in DEV_DATA_FILES) {
+      const base64Data = DEV_DATA_FILES[normalizedPath];
+      const binaryString = atob(base64Data);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes;
+    }
+    
+    throw new Error(`File not found: ${path}. Add this file to the dev-data/ folder for local development.`);
+  },
+};
+
+const biolib: IBioLibGlobals =
+  process.env.NODE_ENV === "development"
+    ? devSdkBioLib
+    : (window as any).biolib;
+
+export default biolib;

biolib/_internal/templates/gui_template/dev-data/output.json

@@ -0,0 +1,7 @@
+{
+  "message": "Example JSON data for development",
+  "results": [
+    { "id": 1, "value": "Sample result 1" },
+    { "id": 2, "value": "Sample result 2" }
+  ]
+}

biolib/_internal/templates/gui_template/package.json

@@ -14,6 +14,7 @@
   },
   "devDependencies": {
     "@tailwindcss/vite": "4.0.14",
+    "@types/node": "20.17.10",
     "@types/react": "18.3.3",
     "@types/react-dom": "18.3.0",
     "@vitejs/plugin-react": "4.2.1",

biolib/_internal/templates/gui_template/vite-plugin-dev-data.ts

@@ -0,0 +1,49 @@
+import type { Plugin } from 'vite';
+import fs from 'fs';
+import path from 'path';
+
+export function devDataPlugin(): Plugin {
+  let isDev = false;
+  
+  return {
+    name: 'dev-data-plugin',
+    configResolved(config) {
+      isDev = config.mode === 'development';
+    },
+    transform(code: string, id: string) {
+      if (id.endsWith('biolib-sdk.ts')) {
+        let injectedCode: string;
+        
+        if (isDev) {
+          const devDataDir = path.join(__dirname, 'dev-data');
+          const devDataMap: Record<string, string> = {};
+          
+          if (fs.existsSync(devDataDir)) {
+            const files = fs.readdirSync(devDataDir);
+            for (const file of files) {
+              const filePath = path.join(devDataDir, file);
+              if (fs.statSync(filePath).isFile()) {
+                const content = fs.readFileSync(filePath);
+                const base64Content = content.toString('base64');
+                devDataMap[file] = base64Content;
+              }
+            }
+          }
+          
+          const devDataJson = JSON.stringify(devDataMap);
+          injectedCode = code.replace(
+            "const DEV_DATA_FILES = {};",
+            `const DEV_DATA_FILES = ${devDataJson};`
+          );
+        } else {
+          injectedCode = code;
+        }
+        
+        return {
+          code: injectedCode,
+          map: null
+        };
+      }
+    }
+  };
+}

biolib/_internal/templates/gui_template/vite.config.mts

@@ -2,7 +2,8 @@ import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 import tailwindcss from "@tailwindcss/vite";
 import { viteSingleFile } from "vite-plugin-singlefile";
+import { devDataPlugin } from "./gui/vite-plugin-dev-data";
 
 export default defineConfig({
-  plugins: [react(), tailwindcss(), viteSingleFile()],
+  plugins: [react(), tailwindcss(), devDataPlugin(), viteSingleFile()],
 });

biolib/_internal/templates/init_template/.github/workflows/biolib.yml

@@ -11,6 +11,11 @@ jobs:
           - name: Build
             run: docker build -t BIOLIB_REPLACE_DOCKER_TAG:latest .
           - name: Push
-            run: biolib push $([ "$GITHUB_REF_NAME" != "main" ] && echo -n "--dev") BIOLIB_REPLACE_APP_URI
+            run: |
+              if [ "$GITHUB_REF_NAME" == "main" ]; then
+                biolib push BIOLIB_REPLACE_APP_URI
+              else
+                biolib push --dev BIOLIB_REPLACE_APP_URI:latest-dev
+              fi
             env:
               BIOLIB_TOKEN: ${{ secrets.BIOLIB_TOKEN }}

biolib/_internal/templates/init_template/Dockerfile

@@ -1,3 +1,5 @@
+# syntax=docker/dockerfile:1
+
 FROM python:3.13.3-slim
 WORKDIR /home/biolib/
 

biolib/_internal/utils/__init__.py

@@ -1,5 +1,31 @@
+import base64
 import time
 import uuid
+from fnmatch import fnmatch
+
+from biolib.biolib_binary_format.utils import LazyLoadedFile
+from biolib.typing_utils import Callable, List, Union, cast
+
+PathFilter = Union[str, Callable[[str], bool]]
+
+
+def filter_lazy_loaded_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)
+
+    # since all file paths start with /, make sure filter does too
+    if not glob_filter.startswith('/'):
+        glob_filter = '/' + glob_filter
+
+    def _filter_function(file: LazyLoadedFile) -> bool:
+        return fnmatch(file.path, glob_filter)
+
+    return list(filter(_filter_function, files))
 
 
 def open_browser_window_from_notebook(url_to_open: str) -> None:
@@ -16,3 +42,17 @@ def open_browser_window_from_notebook(url_to_open: str) -> None:
     display(Javascript(f'window.open("{url_to_open}");'), display_id=display_id)
     time.sleep(1)
     update_display(Javascript(''), display_id=display_id)
+
+
+def base64_encode_string(input_str: str) -> str:
+    input_bytes = input_str.encode('utf-8')
+    base64_bytes = base64.b64encode(input_bytes)
+    base64_str = base64_bytes.decode('utf-8')
+    return base64_str
+
+
+def decode_base64_string(base64_str: str) -> str:
+    base64_bytes = base64_str.encode('utf-8')
+    input_bytes = base64.b64decode(base64_bytes)
+    input_str = input_bytes.decode('utf-8')
+    return input_str

biolib/_internal/utils/auth.py

@@ -0,0 +1,46 @@
+import base64
+import binascii
+import json
+from typing import Any, Dict
+
+
+class JwtDecodeError(Exception):
+    pass
+
+
+def decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
+    jwt_bytes = jwt.encode('utf-8')
+
+    try:
+        signing_input, _ = jwt_bytes.rsplit(b'.', 1)
+        header_segment, payload_segment = signing_input.split(b'.', 1)
+    except ValueError as error:
+        raise JwtDecodeError('Not enough segments') from error
+
+    try:
+        header_data = base64.urlsafe_b64decode(header_segment)
+    except (TypeError, binascii.Error) as error:
+        raise JwtDecodeError('Invalid header padding') from error
+
+    try:
+        header = json.loads(header_data)
+    except ValueError as error:
+        raise JwtDecodeError(f'Invalid header string: {error}') from error
+
+    if not isinstance(header, dict):
+        raise JwtDecodeError('Invalid header string: must be a json object')
+
+    try:
+        payload_data = base64.urlsafe_b64decode(payload_segment)
+    except (TypeError, binascii.Error) as error:
+        raise JwtDecodeError('Invalid payload padding') from error
+
+    try:
+        payload = json.loads(payload_data)
+    except ValueError as error:
+        raise JwtDecodeError(f'Invalid payload string: {error}') from error
+
+    if not isinstance(payload, dict):
+        raise JwtDecodeError('Invalid payload string: must be a json object')
+
+    return dict(header=header, payload=payload)

biolib/_internal/utils/job_url.py

@@ -0,0 +1,33 @@
+import re
+from urllib.parse import urlparse
+
+import biolib.utils
+from biolib.typing_utils import Optional, Tuple
+
+
+def parse_result_id_or_url(result_id_or_url: str, default_token: Optional[str] = None) -> Tuple[str, Optional[str]]:
+    result_id_or_url = result_id_or_url.strip()
+
+    if '/' not in result_id_or_url:
+        return (result_id_or_url, default_token)
+
+    if not result_id_or_url.startswith('http://') and not result_id_or_url.startswith('https://'):
+        result_id_or_url = 'https://' + result_id_or_url
+
+    parsed_url = urlparse(result_id_or_url)
+
+    if biolib.utils.BIOLIB_BASE_URL:
+        expected_base = urlparse(biolib.utils.BIOLIB_BASE_URL)
+        if parsed_url.scheme != expected_base.scheme or parsed_url.netloc != expected_base.netloc:
+            raise ValueError(f'URL must start with {biolib.utils.BIOLIB_BASE_URL}, got: {result_id_or_url}')
+
+    pattern = r'/results?/(?P<uuid>[a-f0-9-]+)/?(?:\?token=(?P<token>[^&]+))?'
+    match = re.search(pattern, result_id_or_url, re.IGNORECASE)
+
+    if not match:
+        raise ValueError(f'URL must be in format <base_url>/results/<UUID>/?token=<token>, got: {result_id_or_url}')
+
+    uuid = match.group('uuid')
+    token = match.group('token') or default_token
+
+    return (uuid, token)

biolib/_runtime/runtime.py

@@ -37,10 +37,19 @@ class Runtime:
             return None
         return job_requested_machine
 
+    @staticmethod
+    def is_spot_machine_requested() -> bool:
+        job_data = Runtime._get_job_data()
+        return job_data.get('job_requested_machine_spot', False)
+
     @staticmethod
     def get_app_uri() -> str:
         return Runtime._get_job_data()['app_uri']
 
+    @staticmethod
+    def get_max_workers() -> int:
+        return Runtime._get_job_data()['job_reserved_machines']
+
     @staticmethod
     def get_secret(secret_name: str) -> bytes:
         assert re.match(

biolib/_session/session.py

@@ -1,21 +1,23 @@
 from biolib import utils
-from biolib._internal.types import Optional
+from biolib.typing_utils import Optional
 from biolib.api.client import ApiClient, ApiClientInitDict
 from biolib.app import BioLibApp
 
 
 class Session:
-    def __init__(self, _init_dict: ApiClientInitDict) -> None:
+    def __init__(self, _init_dict: ApiClientInitDict, _experiment: Optional[str] = None) -> None:
         self._api = ApiClient(_init_dict=_init_dict)
+        self._experiment = _experiment
 
     @staticmethod
-    def get_session(refresh_token: str, base_url: Optional[str] = None, client_type: Optional[str] = None) -> 'Session':
+    def get_session(refresh_token: str, base_url: Optional[str] = None, client_type: Optional[str] = None, experiment: Optional[str] = None) -> 'Session':
         return Session(
             _init_dict=ApiClientInitDict(
                 refresh_token=refresh_token,
                 base_url=base_url or utils.load_base_url_from_env(),
                 client_type=client_type,
-            )
+            ),
+            _experiment=experiment,
         )
 
     def load(self, uri: str, suppress_version_warning: bool = False) -> BioLibApp:
@@ -39,4 +41,4 @@ class Session:
             >>> app = biolib.load('https://biolib.com/biolib/myapp/')
             >>> result = app.cli('--help')
         """
-        return BioLibApp(uri=uri, _api_client=self._api, suppress_version_warning=suppress_version_warning)
+        return BioLibApp(uri=uri, _api_client=self._api, suppress_version_warning=suppress_version_warning, _experiment=self._experiment)