pybiolib 1.2.633__py3-none-any.whl → 1.2.676__py3-none-any.whl

biolib/__init__.py

@@ -4,6 +4,7 @@ from urllib.parse import urlparse as _urlparse
 
 from biolib import typing_utils as _typing_utils
 from biolib.app import BioLibApp as _BioLibApp
+
 # TODO: Fix ignore of type
 from biolib.app.search_apps import search_apps  # type: ignore
 from biolib.biolib_errors import BioLibError
@@ -24,6 +25,7 @@ import biolib.utils
 
 # ------------------------------------ Function definitions for public Python API ------------------------------------
 
+
 def call_cli() -> None:
     biolib.cli.cli()
 
@@ -51,9 +53,9 @@ def load(uri: str) -> _BioLibApp:
 
 
 def search(
-        search_query: Optional[str] = None,
-        team: Optional[str] = None,
-        count: int = 100,
+    search_query: Optional[str] = None,
+    team: Optional[str] = None,
+    count: int = 100,
 ) -> List[str]:
     r"""Search for BioLib applications.
 
@@ -98,6 +100,26 @@ def get_job(job_id: str, job_token: Optional[str] = None) -> _Job:
     return _Job.create_from_uuid(uuid=job_id, auth_token=job_token)
 
 
+def get_result(result_id: str, result_token: Optional[str] = None) -> _Job:
+    r"""Get a result by its ID.
+
+    Args:
+        result_id (str): The UUID of the result to retrieve
+        result_token (str, optional): Authentication token for accessing the result.
+            Only needed for result that aren't owned by the current user.
+
+    Returns:
+        Result: The result object
+
+    Example::
+
+        >>> result = biolib.get_result('abc123')
+        >>> # Access shared result
+        >>> result = biolib.get_result('abc123', result_token='xyz789')
+    """
+    return _Job.create_from_uuid(uuid=result_id, auth_token=result_token)
+
+
 def get_data_record(uri: str) -> _DataRecord:
     r"""Get a data record by its URI.
 
@@ -255,7 +277,7 @@ def set_api_base_url(api_base_url: str) -> None:
     biolib.utils.BIOLIB_BASE_URL = api_base_url
     biolib.utils.BIOLIB_SITE_HOSTNAME = _urlparse(api_base_url).hostname
     biolib.utils.BASE_URL_IS_PUBLIC_BIOLIB = api_base_url.endswith('biolib.com') or (
-            os.environ.get('BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB', '').upper() == 'TRUE'
+        os.environ.get('BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB', '').upper() == 'TRUE'
     )
 
 

biolib/_internal/llm_instructions/.github/copilot-instructions.md

@@ -0,0 +1,7 @@
+Variable names are allowed to be verbose, and should be descriptive.
+
+Code comments should only be added for complex logic or unintuitive code that is not adequately explained by the function names themselves.
+
+Unit tests are not necessary. Tests should instead be written as simple examples demonstrating the functionality of relevant functions.
+
+Always use 4 spaces for indentation when writing code.

biolib/_internal/llm_instructions/.github/prompts/biolib_app_inputs.prompt.md

@@ -0,0 +1,60 @@
+# Main task
+Your task is to make sure that all inputs are handled correctly in the give Python script and/or biolib config file.
+
+Inputs are defined in the [config.yml](../../.biolib/config.yml) file and the main Python script, usually found in [run.py](../../run.py) or [main.py](../../main.py).
+
+# Syntax of config.yml
+The file config.yml contains the information needed to render and run an application on BioLib. This configuration defines the entry to your application and what input arguments the user can set. When you edit an application using the graphical interface on BioLib the config.yml file is automatically updated.
+
+The config file and python script specify how input options and settings will be rendered to the user of the application, and how inputs will be parsed. The input field should follow this structure:
+
+```
+arguments:
+    -   key: --data # required
+        description: 'Input Dropdown' # required
+        key_value_separator: ' ' # optional, default is ' '
+        default_value: '' # optional, default is ''
+        type: dropdown # required
+        options:
+            'This will be shown as option one': 'value1'
+            'This will be shown as option two': 'value2'
+        required: true # optional, default is true
+```
+
+Under `type` you have the following options:
+
+* `text` provides a text input field
+* `file` provides a file select where users can upload an input file
+* `text-file` provides both a text input field and a file select allowing the user supply either
+* `sequence` like text-file, with checks for valid FASTA input characters
+* `hidden` allows the application creator to provide a default input argument without it being shown to the end-user
+* `toggle` provides a toggle switch where users can choose two options. Note that the options need to be named 'on' : 'value1' and 'off': 'value2'
+* `number` provides a number input field
+* `radio` provides a "radio select" where users can select one amongst a number of prespecified options
+* `dropdown` provides a dropdown menu where users can select one amongst a number of prespecified options
+* `multiselect` provides a dropdown menu where users can select one or more prespecified options
+
+`sub_arguments`: Allow you to specify arguments that are only rendered if a user chooses a particular option in the parent argument. For example, an application might allow the user to run one of two commands, where each of these commands would need different input arguments:
+
+```
+arguments:
+    -   key: --function
+        description: 'Choose a function'
+        key_value_separator: ''
+        default_value: ''
+        type: dropdown
+        options:
+            'Command A': a
+            'Command B': b
+        sub_arguments:
+            a:
+                -   key: --argument_a
+                    description: "Argument A takes a file input"
+                    type: file
+            b:
+                -   key: --argument_b
+                    description: 'Argument B takes a text input'
+                    type: text
+```
+
+Inputs in the Python script should be parsed with argparse, and should also enshrine the same requirements and defaults such that use is identical between the frontend and Python.

biolib/_internal/llm_instructions/.github/prompts/biolib_run_apps.prompt.md

@@ -0,0 +1,302 @@
+# BioLib Run Apps Prompt
+Your task is to run some kind of apps at the users discretion. Here are instructions on how running an app works.
+
+## Login
+
+You need to be logged in, unless this is running as part of a different app. To log in with your BioLib account in a Python notebook run the code below and follow the instructions shown:
+
+```python
+import biolib
+biolib.login()
+```
+
+Alternatively, you can use an API token and set it as the `BIOLIB_TOKEN` environment variable. If the user requests this, direct them [here](https://biolib.com/settings/api-tokens/).
+
+## Run using .cli()
+
+To load an application into your Python script, add the following:
+
+```python
+import biolib
+app = biolib.load('author/application')
+```
+
+To run an application call the function `.cli()` on the application you loaded above. For instance, to run samtools with the `--help` command:
+
+```python
+import biolib
+
+samtools = biolib.load('samtools/samtools')
+job = samtools.cli(args='--help')
+print(job.get_stdout().decode())
+```
+
+Running an application returns a job object, which allows you to monitor progress and save results.
+
+## Non blocking
+
+By default, calling the function `.cli()` blocks until the application is finished. You can pass the keyword argument `blocking=False` to return immediately. For example the code below will print "in_progress":
+
+```python
+import biolib
+
+samtools = biolib.load('samtools/samtools')
+job = samtools.cli(args='--help', blocking=False)
+print(job.get_status())
+```
+
+## Result prefix
+
+You can annotate the result with a custom name when calling `.cli()` using the keyword argument `result_prefix` as:
+
+```python
+import biolib
+
+samtools = biolib.load('samtools/samtools')
+job = samtools.cli(args='--help', result_prefix='my_help_test')
+```
+
+Setting the result prefix makes it easy to distinguish results from one another on the result page.
+
+## Run using .run()
+
+The `.run()` function is a more Pythonic way to run applications where all keyword arguments are passed to the application as command line arguments. This function blocks and waits until the application is finished.
+
+```python
+samtools = biolib.load('samtools/samtools')
+job = samtools.run()
+```
+
+## Run using .start()
+
+The `.start()` function is a more Pythonic way to run applications where all keyword arguments are passed to the application as command line arguments. This function returns immediately when the job is created.
+
+```python
+samtools = biolib.load('samtools/samtools')
+job = samtools.start()
+```
+
+## Search
+
+To search for applications on BioLib use the function `biolib.search()` which takes a search query as the first argument:
+
+```python
+app_list = biolib.search('samtools')
+print(app_list)
+```
+
+Should print something like below:
+
+```
+['samtools/samtools',
+ 'samtools/samtools-fixmate',
+ 'samtools/samtools-stats',
+ 'samtools/samtools-collate',
+ 'samtools/samtools-fastq',
+ ...]
+```
+
+To run a specific application you can pass a value from the list above to `biolib.load()` and then call `app.cli()`:
+
+```python
+app = biolib.load(app_list[0])
+job = app.cli('--help')
+```
+
+## Results
+
+When a job has completed, its outputs can be accessed by the following functions:
+
+```python
+job.wait()          # Wait until done
+job.get_stdout()    # Returns stdout as bytes
+job.get_stderr()    # Returns stderr as bytes
+job.get_exit_code() # Returns exit code of the application as an integer
+```
+
+## Save files to disk
+
+To save the output files to a local directory like "result_files" run:
+
+```python
+job.save_files(output_dir='result_files')
+```
+
+The `.save_files()` function also takes an optional `path_filter` argument as a glob pattern. For example to save all `.pdb` files from a result you can run:
+
+```python
+job.save_files(output_dir='result_files', path_filter='*.pdb')
+```
+
+## In memory files
+
+Work with result files without saving them to disk. To list the output files from a job:
+
+```python
+job.list_output_files()
+```
+
+To load a single file into memory, without saving it to disk, run:
+
+```python
+my_csv_file = job.get_output_file('/my_file.csv')
+```
+
+To pass an output file to a library like Pandas or BioPython, run `.get_file_handle()` on the object:
+
+```python
+import pandas as pd
+my_dataframe = pd.read_csv(my_csv_file.get_file_handle())
+```
+
+## Jobs
+
+A job object refers to a specific run of an application. It holds progress information of the application run and the result when the job has completed.
+
+### List jobs
+
+When signed in, you can print a table of your jobs by running:
+
+```python
+biolib.show_jobs(count=25)
+```
+
+where count refers to the number of jobs you want to show.
+
+### Retrieve a job
+
+To retrieve a Job in python call `biolib.get_job()` with the Job's ID.
+
+```python
+job = biolib.get_job(job_id)
+print(job.get_status())
+```
+
+You can use this to determine if a job has completed or is still in progress.
+
+### Open in browser
+
+You can open the job in your web browser to view the graphical and interactive output files.
+
+```python
+job.open_browser()
+```
+
+### Stream output
+
+If your Job is still running you can attach to its stdout and stderr by running:
+
+```python
+job.stream_logs()
+```
+
+This will print current output and keep streaming stdout and stderr until the job has finished.
+
+### Download output files
+
+You can download job output files using the job ID. The job ID can be found under "Details" on the Results page, or in the share link:
+
+```python
+job_id = '1a234567-b89...'
+job = biolib.get_job(job_id)
+job.save_files('job_output/')
+```
+
+### Download input files
+
+To download the input files of a job:
+
+```python
+job_id = '1a234567-b89...'
+job = biolib.get_job(job_id)
+job.save_input_files(output_dir='input_files')
+```
+
+## Start jobs in parallel
+
+Use the `blocking=False` argument to `.cli()` on an application to get the job immediately without having to wait for the application to finish.
+
+This feature allows for parallelized workflows as the one below:
+
+```python
+samtools = biolib.load('samtools/samtools')
+my_fasta_files = ['seq1.fasta', 'seq2.fasta']
+
+my_jobs = []
+for file in my_fasta_files:
+    job = samtools.cli(file, blocking=False)
+    my_jobs.append(job)
+```
+
+## Experiments
+
+An Experiment is a collection of jobs that you can retrieve together. To group the jobs in an Experiment use the following syntax:
+
+```python
+with biolib.Experiment('my-experiment-name'):
+    my_application.cli(input_1) # these two jobs will be
+    my_application.cli(input_2) # grouped in the same Experiment
+```
+
+All jobs started under the with statement will be grouped under the Experiment's ID (in this case `my-experiment-name`).
+
+### List experiments
+
+When logged in, you can print a table of your experiments by running:
+
+```python
+biolib.show_experiments(count=10)
+```
+
+where count refers to the number of experiments you want to show.
+
+### Retrieve an experiment
+
+To load an Experiment in Python, run the following:
+
+```python
+my_experiment = biolib.get_experiment('my-experiment-name')
+print(my_experiment)
+```
+
+### Wait for all jobs
+
+To block and wait until all jobs of an experiment have finished, use the `.wait()` function:
+
+```python
+my_experiment.wait()
+```
+
+### Retrieve jobs
+
+To get a list of the Job objects contained in an Experiment, run:
+
+```python
+my_jobs = my_experiment.get_jobs()
+for job in my_jobs:
+    # Print output
+    if job.get_status() == 'completed':
+        print(job.get_stdout())
+    else:
+        job.stream_logs()
+
+    # Save output files
+    job.save_files('my_results')
+```
+
+### List jobs in an Experiment
+
+To show an overview of the jobs in your experiment run:
+
+```python
+my_experiment.show_jobs()
+```
+
+This prints a table of the jobs contained in your experiment.
+
+### Mount files
+
+Using `.mount_files()` you can mount all jobs of the experiment and their output files to a local directory. This allows you to explore all the files in the experiment using your file browser.
+
+```python
+my_experiment.mount_files(mount_path='my_local_directory')

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[37m',
+    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
+        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/cli/__init__.py

@@ -5,7 +5,7 @@ import click
 
 from biolib import utils
 from biolib.biolib_logging import logger, logger_no_user_data
-from biolib.cli import auth, data_record, download_container, init, lfs, push, run, runtime, start
+from biolib.cli import auth, data_record, download_container, init, lfs, push, run, runtime, sdk, start
 
 
 @click.version_option(version=utils.BIOLIB_PACKAGE_VERSION, prog_name='pybiolib')
@@ -31,6 +31,7 @@ cli.add_command(run.run)
 cli.add_command(runtime.runtime)
 cli.add_command(start.start)
 cli.add_command(data_record.data_record)
+cli.add_command(sdk.sdk)
 
 # allow this script to be called without poetry in dev e.g. by an IDE debugger
 if utils.IS_DEV and __name__ == '__main__':

biolib/cli/sdk.py

@@ -0,0 +1,53 @@
+import os
+import shutil
+import sys
+
+import click
+
+from biolib._internal import llm_instructions
+
+
+@click.group(name='sdk', help='Advanced commands for developers')
+def sdk():
+    pass
+
+
+@sdk.command(
+    name='add-copilot-prompts', help='Add BioLib-specific GitHub Copilot prompts and instructions to your repository'
+)
+@click.option('--force', is_flag=True, help='Force overwrite existing files.')
+def add_copilot_prompts(force: bool) -> None:
+    current_working_directory = os.getcwd()
+    config_file_path = f'{current_working_directory}/.biolib/config.yml'
+    if not os.path.exists(config_file_path):
+        err_string = """
+Error: Current directory has not been initialized as a BioLib application.
+       Please run the "biolib init" command first"""
+        click.echo(err_string, file=sys.stderr)
+        exit(1)
+    source_path = os.path.join(os.path.dirname(llm_instructions.__file__), '.github')
+    destination_path = os.path.join(current_working_directory, '.github')
+
+    conflicting_files = []
+
+    for root, _, files in os.walk(source_path):
+        relative_dir = os.path.relpath(root, source_path)
+        destination_dir = os.path.join(destination_path, relative_dir)
+        for file in files:
+            source_file = os.path.join(root, file)
+            destination_file = os.path.join(destination_dir, file)
+            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:
+        click.echo('The following files were not overwritten. Use --force to override them:', file=sys.stderr)
+        for conflicting_file in conflicting_files:
+            click.echo(f'  {conflicting_file}', file=sys.stderr)
+        exit(1)
+
+    click.echo(f'Prompt and instruction files added to {destination_path}/')

biolib/jobs/job.py

@@ -9,6 +9,7 @@ from urllib.parse import urlparse
 import biolib.api.client
 from biolib import utils
 from biolib._internal.http_client import HttpClient
+from biolib._internal.tree_utils import build_tree_from_files, build_tree_str
 from biolib._internal.utils import open_browser_window_from_notebook
 from biolib.api.client import ApiClient
 from biolib.biolib_api_client import BiolibApiClient, CreatedJobDict
@@ -56,7 +57,48 @@ class Job:
         return f"Job for {self._job_dict['app_uri']} created at {self._job_dict['created_at']} ({self._uuid})"
 
     def __repr__(self):
-        return f'Job: {self._uuid}'
+        # Get job status and shareable link
+        status = self.get_status()
+        shareable_link = self.get_shareable_link()
+
+        # ANSI color codes for terminal output
+        blue = '\033[34m'
+        white = '\033[37m'
+        reset = '\033[0m'
+
+        # Start with the header section
+        output_lines = [
+            '--- BioLib Result ---',
+            f'ID: {self._uuid}',
+            f'Status: {status}',
+            f'Link: {shareable_link}',
+        ]
+
+        # Only show output files if the job is not pending
+        if not self.is_pending():
+            output_lines.append('Output Files:')
+
+            try:
+                # Get files from the job
+                files = self.list_output_files()
+
+                # If no files, indicate that
+                if not files:
+                    output_lines.append('No output files')
+                    return '\n'.join(output_lines)
+
+                # If more than 25 files, show simplified message
+                if len(files) > 25:
+                    output_lines.append(f'{len(files)} output files in result.')
+                    return '\n'.join(output_lines)
+
+                # Build the tree representation
+                tree_data = build_tree_from_files(files)
+                output_lines.extend(build_tree_str(tree_data, blue=blue, white=white, reset=reset))
+            except Exception:
+                output_lines.append('Error accessing output files')
+
+        return '\n'.join(output_lines)
 
     @property
     def id(self) -> str:  # pylint: disable=invalid-name
@@ -128,6 +170,21 @@ class Job:
         self,
         path_filter: Optional[PathFilter] = None,
     ) -> List[LazyLoadedFile]:
+        """List output files from the job.
+
+        Args:
+            path_filter (PathFilter, optional): Filter to apply to the output files.
+                Can be a string glob pattern or a callable that takes a path string and returns a boolean.
+
+        Returns:
+            List[LazyLoadedFile]: List of output files.
+
+        Example::
+            >>> job = biolib.get_job("job_id")
+            >>> output_files = job.list_output_files()
+            >>> # Filter files with a glob pattern
+            >>> output_files = job.list_output_files("*.pdb")
+        """
         return self.result.list_output_files(path_filter=path_filter)
 
     def get_output_file(self, filename: str) -> LazyLoadedFile:

{pybiolib-1.2.633.dist-info → pybiolib-1.2.676.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pybiolib
-Version: 1.2.633
+Version: 1.2.676
 Summary: BioLib Python Client
 License: MIT
 Keywords: biolib

{pybiolib-1.2.633.dist-info → pybiolib-1.2.676.dist-info}/RECORD

@@ -1,4 +1,4 @@
-biolib/__init__.py,sha256=nPgMXXoJ4wqGwDqMgwtAYrw_-GVMdaWwKemOpRKKljU,9774
+biolib/__init__.py,sha256=9uAH7V0r3t3tEA3Lx0mbd9b9rTI1fRt-rGzkRvwMfZw,10402
 biolib/_data_record/data_record.py,sha256=zKvnh5T-dIVY46-kgVzMBoZ666ZhcTCFQnWvZT0D6RM,12026
 biolib/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/_internal/data_record/__init__.py,sha256=fGdME6JGRU_2VxpJbYpGXYndjN-feUkmKY4fuMyq3cg,76
@@ -13,8 +13,13 @@ biolib/_internal/lfs/__init__.py,sha256=gSWo_xg61UniYgD7yNYxeT4I9uaXBCBSi3_nmZjn
 biolib/_internal/lfs/cache.py,sha256=pQS2np21rdJ6I3DpoOutnzPHpLOZgUIS8TMltUJk_k4,2226
 biolib/_internal/libs/__init__.py,sha256=Jdf4tNPqe_oIIf6zYml6TiqhL_02Vyqwge6IELrAFhw,98
 biolib/_internal/libs/fusepy/__init__.py,sha256=AWDzNFS-XV_5yKb0Qx7kggIhPzq1nj_BZS5y2Nso08k,41944
+biolib/_internal/llm_instructions/.github/copilot-instructions.md,sha256=7xW_wXe-2QAJnMnyANGLd_RTB7Nw0BX_2crKLQUUMYc,403
+biolib/_internal/llm_instructions/.github/prompts/biolib_app_inputs.prompt.md,sha256=DcBUNaViuNfXoomj-IVUcIcBtJlXuIYOroUfDM_R6wU,3212
+biolib/_internal/llm_instructions/.github/prompts/biolib_run_apps.prompt.md,sha256=HYv-MgpQKIU7Hv90SvZ3tqXY6KWxYVnqamXDRyInOHM,7926
+biolib/_internal/llm_instructions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/_internal/push_application.py,sha256=Ffj3iZ0nma4KHTB-PKCeFvhCHHhAEhgKClxnfBUpL8U,12296
 biolib/_internal/runtime.py,sha256=BiHl4klUHr36MCpqKaUso4idHeBZfPAahLYRQrabFqA,486
+biolib/_internal/tree_utils.py,sha256=F7Uw_ymEB_IFWPYvvRYG00jajE4aml0KSwQYsHW_AF0,3754
 biolib/_internal/types/__init__.py,sha256=xLgOQJFh3GRtiqIJq7MaqHReZx4pp34_zcaFQ_JjuJ4,198
 biolib/_internal/types/app.py,sha256=Mz2QGD_jESX-K9JYnLWPo4YA__Q_1FQQTk9pvidCohU,118
 biolib/_internal/types/data_record.py,sha256=9r_vdhVs60YTnzU4XQFXfDrfS2P2MqD3BH2xa7lk6ck,852
@@ -58,7 +63,7 @@ biolib/biolib_docker_client/__init__.py,sha256=aBfA6mtWSI5dBEfNNMD6bIZzCPloW4ghK
 biolib/biolib_download_container.py,sha256=8TmBV8iv3bCvkNlHa1SSsc4zl0wX_eaxhfnW5rvFIh8,1779
 biolib/biolib_errors.py,sha256=eyQolC4oGi350BDEMOd-gAHYVqo2L2lYgv6c4ZdXPjQ,1184
 biolib/biolib_logging.py,sha256=S2y6fk7jjxZQMN2BtKkHBb4JbVQQSSU97T7ep4P_QCE,2855
-biolib/cli/__init__.py,sha256=0v3c_J-U0k46c5ZWeQjLG_kTaKDJm81LBxQpDO2B_aI,1286
+biolib/cli/__init__.py,sha256=IHC2bEyA27pvgp-18SGfFVJOP456elanz7suDP8D084,1316
 biolib/cli/auth.py,sha256=rpWGmXs6Fz6CGrO9K8ibPRszOdXG78Vig_boKaVCD9A,2082
 biolib/cli/data_record.py,sha256=t8DfJK2EZ_SNZ9drDA_N5Jqy8DNwf9f5SlFrIaOvtv0,3501
 biolib/cli/download_container.py,sha256=HIZVHOPmslGE5M2Dsp9r2cCkAEJx__vcsDz5Wt5LRos,483
@@ -67,6 +72,7 @@ biolib/cli/lfs.py,sha256=z2qHUwink85mv9yDgifbVKkVwuyknGhMDTfly_gLKJM,4151
 biolib/cli/push.py,sha256=RxB4RHpjtL27Fpq7WRGojJ53R9jUuE1Cq9_NmHFzNsM,1306
 biolib/cli/run.py,sha256=MCo0ZqW2pHBxOoCI3i5gAx5D0auW9fmxHqkAF4TRhms,2134
 biolib/cli/runtime.py,sha256=Xv-nrma5xX8NidWcvbUKcUvuN5TCarZa4A8mPVmF-z0,361
+biolib/cli/sdk.py,sha256=YTeriA-jC5XuEbhMMQ4DlOZXM2y0vN5YsKDNoAeZao8,2140
 biolib/cli/start.py,sha256=rg8VVY8rboFhf1iQo3zE3WA5oh_R1VWWfYJEO1gMReY,1737
 biolib/compute_node/.gitignore,sha256=GZdZ4g7HftqfOfasFpBC5zV1YQAbht1a7EzcXD6f3zg,45
 biolib/compute_node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -102,7 +108,7 @@ biolib/compute_node/webserver/worker_thread.py,sha256=7uD9yQPhePYvP2HCJ27EeZ_h6p
 biolib/experiments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/experiments/experiment.py,sha256=pBtnOHz0kKoFxlIGf08o8ZCEOze-CljwfOsTdhvCTCk,8646
 biolib/jobs/__init__.py,sha256=aIb2H2DHjQbM2Bs-dysFijhwFcL58Blp0Co0gimED3w,32
-biolib/jobs/job.py,sha256=rcQPLrUsVHdzZ0g_T9f3m_mmVF0m-aYi_fKYTbQATaA,24174
+biolib/jobs/job.py,sha256=nHSYUIUcvujfh6Q85j1qLGIWzXKwp4kEou8ywhngJlQ,26276
 biolib/jobs/job_result.py,sha256=rALHiKYNaC9lHi_JJqBob1RubzNLwG9Z386kwRJjd2M,5885
 biolib/jobs/types.py,sha256=ezvaoTANsWazK6PmfpYcqezdfjP7MNBEBfqIZGoZhz8,997
 biolib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -120,8 +126,8 @@ biolib/utils/cache_state.py,sha256=u256F37QSRIVwqKlbnCyzAX4EMI-kl6Dwu6qwj-Qmag,3
 biolib/utils/multipart_uploader.py,sha256=XvGP1I8tQuKhAH-QugPRoEsCi9qvbRk-DVBs5PNwwJo,8452
 biolib/utils/seq_util.py,sha256=Ozk0blGtPur_D9MwShD02r_mphyQmgZkx-lOHOwnlIM,6730
 biolib/utils/zip/remote_zip.py,sha256=0wErYlxir5921agfFeV1xVjf29l9VNgGQvNlWOlj2Yc,23232
-pybiolib-1.2.633.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
-pybiolib-1.2.633.dist-info/METADATA,sha256=3AF7yKFrHFCcuoXGh_XLgYlEijDF3TTIpzzCRjiZ524,1570
-pybiolib-1.2.633.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-pybiolib-1.2.633.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
-pybiolib-1.2.633.dist-info/RECORD,,
+pybiolib-1.2.676.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+pybiolib-1.2.676.dist-info/METADATA,sha256=G4xSrKTCsELugTDbRh4vW_ytO7BMKvRWUgpTQ97Z_-I,1570
+pybiolib-1.2.676.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+pybiolib-1.2.676.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
+pybiolib-1.2.676.dist-info/RECORD,,