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

biolib/_internal/templates/dashboard_template/.biolib/config.yml

@@ -0,0 +1,5 @@
+biolib_version: 2
+assets: dist/
+modules:
+    main:
+        image: "assets://index.html"

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

@@ -0,0 +1,21 @@
+name: BioLib Build & Push
+on: push
+concurrency:
+  group: ${{ github.repository }}
+  cancel-in-progress: false
+jobs:
+    build-and-push:
+        runs-on: biolib-github-runner
+        steps:
+          - uses: actions/checkout@v4
+          - name: Build
+            run: BIOLIB_REPLACE_BUILD_COMMAND
+          - name: Push
+            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/gitignore_template/.gitignore

@@ -0,0 +1,10 @@
+# Python
+*__pycache__*
+*.pyc
+
+# GUI
+.yarn
+dist
+yarn.lock
+tsconfig.tsbuildinfo
+node_modules

biolib/_internal/templates/gui_template/.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

biolib/_internal/templates/gui_template/App.tsx

@@ -0,0 +1,53 @@
+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 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 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

@@ -0,0 +1,27 @@
+# syntax=docker/dockerfile:1
+
+FROM node:24.4.1-alpine3.21 AS gui_builder
+
+WORKDIR /home/biolib/
+
+RUN corepack enable
+COPY .yarnrc.yml .
+COPY package.json .
+COPY vite.config.mts .
+RUN yarn install
+
+COPY gui gui
+RUN yarn build
+
+FROM python:3.13.5-slim
+WORKDIR /home/biolib/
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY run.sh .
+COPY run.py .
+
+RUN mkdir output
+
+COPY --from=gui_builder /home/biolib/gui/dist/index.html result.html

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

@@ -0,0 +1,82 @@
+interface IGetFileFromDataRecordOptions {
+  uri: string;
+  path: string;
+}
+
+interface IRunJobPayload {
+  appUri: string;
+  arguments: string[];
+  files: Record<string, { data: Uint8Array }>;
+  temporaryClientSecrets?: Record<string, string>;
+  openResult?: boolean | 'currentWindow' | 'newTab';
+  blocking?: boolean;
+}
+
+interface IJobProgress {
+  logMessage?: string;
+  systemLogMessage?: string;
+  jobId: string;
+}
+
+interface IJobResult {
+  exit_code: number;
+  stderr: Uint8Array;
+  stdout: Uint8Array;
+  files: Record<string, { data: Uint8Array }>;
+  jobId: string;
+}
+
+interface IPendingJobResult {
+  jobId: string;
+  authToken: string;
+}
+
+interface IBioLibGlobals {
+  getFileDataFromDataRecord: (options: IGetFileFromDataRecordOptions) => Promise<Uint8Array>;
+  getOutputFileData: (path: string) => Promise<Uint8Array>;
+  listOutputFilePaths: () => Promise<string[]>;
+  runJob: (payload: IRunJobPayload, jobProgressHandler?: (jobProgress: IJobProgress) => void) => Promise<IJobResult | IPendingJobResult>;
+}
+
+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 = {
+  getFileDataFromDataRecord: async (_options: IGetFileFromDataRecordOptions): Promise<Uint8Array> => {
+    throw new Error('getFileDataFromDataRecord is not available in local development mode.');
+  },
+  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.`);
+  },
+  listOutputFilePaths: async (): Promise<string[]> => {
+    throw new Error('listOutputFilePaths is not available in local development mode.');
+  },
+  runJob: async (_payload: IRunJobPayload, _jobProgressHandler?: (jobProgress: IJobProgress) => void): Promise<IJobResult | IPendingJobResult> => {
+    throw new Error('runJob is not available in local development mode.');
+  },
+};
+
+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/index.css

@@ -0,0 +1,5 @@
+@import "tailwindcss";
+
+* {
+  font-family: "Noto Sans", sans-serif;
+}

biolib/_internal/templates/gui_template/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link href="index.css" rel="stylesheet">
+    <title>BIOLIB_REPLACE_APP_NAME</title>
+  </head>
+  <body style="overflow: hidden; background: white">
+    <div id="root"></div>
+    <script type="module" src="index.tsx"></script>
+  </body>
+</html>

biolib/_internal/templates/gui_template/index.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App.tsx";
+import "./index.css";
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);

biolib/_internal/templates/gui_template/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "biolib_replace_app_name",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit -p gui/tsconfig.json && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "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",
+    "tailwindcss": "4.0.14",
+    "typescript": "5.2.2",
+    "vite": "5.3.4",
+    "vite-plugin-singlefile": "2.0.2"
+  },
+  "packageManager": "yarn@4.6.0"
+}

biolib/_internal/templates/gui_template/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["."]
+}

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

@@ -0,0 +1,50 @@
+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 entries = fs.readdirSync(devDataDir, { recursive: true });
+            for (const entry of entries) {
+              const relativePath = entry.toString();
+              const fullPath = path.join(devDataDir, relativePath);
+              if (fs.statSync(fullPath).isFile()) {
+                const content = fs.readFileSync(fullPath);
+                const base64Content = content.toString('base64');
+                devDataMap[relativePath] = 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

@@ -0,0 +1,10 @@
+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({
+  root: "gui",
+  plugins: [react(), tailwindcss(), devDataPlugin(), viteSingleFile()],
+});

biolib/_internal/templates/init_template/.biolib/config.yml

@@ -0,0 +1,19 @@
+biolib_version: 2
+
+modules:
+    main:
+        image: 'local-docker://BIOLIB_REPLACE_DOCKER_TAG:latest'
+        command: "bash run.sh"
+        working_directory: /home/biolib/
+        input_files:
+            - COPY / /home/biolib/
+        output_files:
+            - COPY /home/biolib/output/ /
+
+BIOLIB_REPLACE_GUI_CONFIG
+arguments:
+    -
+        key: --input
+        description: 'Input protein sequences'
+        type: sequence
+        required: true

biolib/_internal/templates/init_template/Dockerfile

@@ -0,0 +1,14 @@
+# syntax=docker/dockerfile:1
+
+FROM python:3.13.3-slim
+WORKDIR /home/biolib/
+
+RUN pip install --no-cache-dir uv
+
+COPY requirements.txt .
+RUN uv pip install --no-cache-dir --system -r requirements.txt
+
+COPY run.sh .
+COPY run.py .
+
+RUN mkdir output

biolib/_internal/templates/init_template/requirements.txt

@@ -0,0 +1 @@
+pybiolib==BIOLIB_REPLACE_PYBIOLIB_VERSION

biolib/_internal/templates/init_template/run.py

@@ -0,0 +1,12 @@
+import argparse
+
+from biolib.sdk import Runtime
+
+parser = argparse.ArgumentParser(description='Process some biological sequences.')
+parser.add_argument('--input', type=str, required=True, help='Input protein sequences')
+args = parser.parse_args()
+
+# update the BioLib result name based on the provided file
+Runtime.set_result_name_from_file(args.input)
+
+print(f'Processing input file {args.input}...')

biolib/_internal/templates/init_template/run.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+BIOLIB_REPLACE_GUI_MV_COMMAND
+python3 run.py "$@"

biolib/_internal/templates/templates.py

@@ -0,0 +1,25 @@
+import os
+
+
+def init_template() -> str:
+    return os.path.join(os.path.dirname(__file__), 'init_template')
+
+
+def copilot_template() -> str:
+    return os.path.join(os.path.dirname(__file__), 'copilot_template')
+
+
+def gui_template() -> str:
+    return os.path.join(os.path.dirname(__file__), 'gui_template')
+
+
+def dashboard_template() -> str:
+    return os.path.join(os.path.dirname(__file__), 'dashboard_template')
+
+
+def gitignore_template() -> str:
+    return os.path.join(os.path.dirname(__file__), 'gitignore_template')
+
+
+def github_workflow_template() -> str:
+    return os.path.join(os.path.dirname(__file__), 'github_workflow_template')

biolib/_internal/tree_utils.py

@@ -0,0 +1,106 @@
+"""Utilities for displaying file trees and formatting file sizes."""
+
+from typing import Any, Dict, List, Optional, Union
+
+from biolib.biolib_binary_format.utils import LazyLoadedFile
+
+
+def format_size(size_bytes: int) -> str:
+    """Convert bytes to human-readable format (e.g., 2.5KB).
+
+    Args:
+        size_bytes: File size in bytes
+
+    Returns:
+        Human-readable string representation of the file size
+    """
+    if size_bytes < 1024:
+        return f'{size_bytes}B'
+    elif size_bytes < 1024 * 1024:
+        return f'{size_bytes/1024:.1f}KB'
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f'{size_bytes/(1024*1024):.1f}MB'
+    else:
+        return f'{size_bytes/(1024*1024*1024):.1f}GB'
+
+
+def build_tree_str(
+    data: Dict[str, Any],
+    prefix: str = '',
+    tree_lines: Optional[List[str]] = None,
+    blue: str = '\033[34m',
+    white: str = '\033[90m',  # Changed from white (37m) to dark gray (90m) for better visibility on light backgrounds
+    reset: str = '\033[0m',
+) -> List[str]:
+    """Build a string representation of a file tree with color-coded directories and files.
+
+    Args:
+        data: Hierarchical tree structure of directories and files
+        prefix: Line prefix for indentation and tree structure characters
+        tree_lines: List to accumulate tree lines
+        blue: ANSI color code for directories
+        white: ANSI color code for files (defaults to dark gray for visibility on light backgrounds)
+        reset: ANSI color code to reset color
+
+    Returns:
+        List of tree lines for display
+    """
+    if tree_lines is None:
+        tree_lines = []
+
+    # Get sorted items, keeping directories first
+    items = sorted([(k, v) for k, v in data.items() if k != '__files__'])
+    files_list = sorted(data.get('__files__', []), key=lambda f: f['name'])
+
+    # Add directories
+    for i, (key, value) in enumerate(items):
+        is_last_dir = i == len(items) - 1 and not files_list
+
+        if is_last_dir:
+            tree_lines.append(f'{prefix}└── {blue}{key}{reset}')
+            build_tree_str(value, prefix + '    ', tree_lines, blue, white, reset)
+        else:
+            tree_lines.append(f'{prefix}├── {blue}{key}{reset}')
+            build_tree_str(value, prefix + '│   ', tree_lines, blue, white, reset)
+
+    # Add files with their sizes
+    for i, file in enumerate(files_list):
+        is_last = i == len(files_list) - 1
+        size_str = format_size(file['size'])
+        file_name = file['name']
+
+        if is_last:
+            tree_lines.append(f'{prefix}└── {white}{file_name} ({size_str}){reset}')
+        else:
+            tree_lines.append(f'{prefix}├── {white}{file_name} ({size_str}){reset}')
+
+    return tree_lines
+
+
+def build_tree_from_files(files: List[LazyLoadedFile]) -> Dict[str, Union[Dict[str, Any], List[Dict[str, Any]]]]:
+    """Build a hierarchical tree structure from a list of files.
+
+    Args:
+        files: List of files to organize into a tree
+
+    Returns:
+        Hierarchical tree structure of directories and files
+    """
+    tree: Dict[str, Union[Dict[str, Any], List[Dict[str, Any]]]] = {}
+    for file in files:
+        parts = file.path.lstrip('/').split('/')
+        current: Dict[str, Union[Dict[str, Any], List[Dict[str, Any]]]] = tree
+        for i, part in enumerate(parts):
+            if i == len(parts) - 1:  # This is a file
+                if '__files__' not in current:
+                    current['__files__'] = []
+                files_list = current['__files__']
+                assert isinstance(files_list, list)
+                files_list.append({'name': part, 'size': file.length})
+            else:  # This is a directory
+                if part not in current:
+                    current[part] = {}
+                dir_dict = current[part]
+                assert isinstance(dir_dict, dict)
+                current = dir_dict
+    return tree

biolib/_internal/utils/__init__.py

@@ -0,0 +1,65 @@
+import base64
+import shutil
+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:
+    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)
+
+
+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
+
+
+def get_pip_command() -> str:
+    if shutil.which('uv'):
+        return 'uv pip'
+    return 'pip'

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)