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

biolib/cli/init.py

@@ -0,0 +1,421 @@
+import os
+import shutil
+import subprocess
+import sys
+
+import click
+
+from biolib import (
+    biolib_errors,
+    utils,  # Import like this to let BASE_URL_IS_PUBLIC_BIOLIB be set correctly
+)
+from biolib._internal.add_copilot_prompts import add_copilot_prompts
+from biolib._internal.add_gui_files import add_gui_files
+from biolib._internal.http_client import HttpClient, HttpError
+from biolib._internal.string_utils import normalize_for_docker_tag
+from biolib._internal.templates import templates
+from biolib._internal.utils import get_pip_command
+from biolib.api import client as api_client
+from biolib.biolib_api_client.api_client import BiolibApiClient
+from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
+from biolib.biolib_logging import logger_no_user_data
+from biolib.typing_utils import Dict, List, Optional, Set
+from biolib.user.sign_in import sign_in
+from biolib.utils import BIOLIB_PACKAGE_VERSION
+
+
+def _get_latest_pypi_version() -> Optional[str]:
+    try:
+        response = HttpClient.request(
+            url='https://pypi.org/pypi/pybiolib/json',
+            timeout_in_seconds=5,
+            retries=1,
+        )
+        data = response.json()
+        version = data.get('info', {}).get('version')
+        if isinstance(version, str):
+            return version
+        return None
+    except Exception as error:
+        logger_no_user_data.debug(f'Failed to fetch latest version from PyPI: {error}')
+        return None
+
+
+def _is_current_version_outdated(current: str, latest: str) -> bool:
+    try:
+        current_parts = [int(x) for x in current.split('.')]
+        latest_parts = [int(x) for x in latest.split('.')]
+        return current_parts < latest_parts
+    except (ValueError, AttributeError):
+        return False
+
+
+def _check_version_and_prompt_upgrade() -> bool:
+    latest_version = _get_latest_pypi_version()
+    if latest_version and _is_current_version_outdated(BIOLIB_PACKAGE_VERSION, latest_version):
+        print(f'A newer version of pybiolib is available: {latest_version} (current: {BIOLIB_PACKAGE_VERSION})')
+        pip_command = get_pip_command()
+        print(f'To upgrade, run: {pip_command} install --upgrade pybiolib')
+        print()
+        continue_input = input('Do you want to continue with the current version? [y/N]: ')
+        if continue_input.lower() not in ['y', 'yes']:
+            print('Please upgrade pybiolib and run `biolib init` again.')
+            return False
+    return True
+
+
+def _prompt_for_app_uri(prompt_text: str) -> Optional[str]:
+    app_uri = input(prompt_text)
+
+    if app_uri and not app_uri.startswith('@'):
+        try:
+            response = api_client.get('system/enterprise/config/', authenticate=False)
+            config = response.json()
+            prefix = config.get('resource_hostname_prefix')
+            if prefix:
+                app_uri = f'@{prefix}/{app_uri}'
+                print(f'Detected enterprise deployment, using URI: {app_uri}')
+        except HttpError as error:
+            if error.code not in [404, 501]:
+                print(f'Warning: Could not detect enterprise configuration: {error}')
+        except Exception as error:
+            print(f'Warning: Could not detect enterprise configuration: {error}')
+
+    return app_uri if app_uri else None
+
+
+def _validate_or_create_app(app_uri: str) -> bool:
+    try:
+        if BiolibApiClient.is_reauthentication_needed():
+            sign_in_input = input('You need to sign in to validate/create apps. Would you like to sign in? [y/N]: ')
+            if sign_in_input.lower() in ['y', 'yes']:
+                sign_in()
+            else:
+                print('Skipping app validation and creation. You can set the URI in .biolib/config.yml later.')
+                return False
+
+        BiolibAppApi.get_by_uri(app_uri)
+        print(f'App {app_uri} already exists.')
+    except biolib_errors.NotFound:
+        create_app_input = input(f'App {app_uri} does not exist. Would you like to create it? [y/N]: ')
+        if create_app_input.lower() in ['y', 'yes']:
+            try:
+                BiolibAppApi.create_app(app_uri)
+                print(f'Successfully created app {app_uri}')
+            except Exception as error:
+                print(f'Failed to create app {app_uri}: {str(error)}')
+                print('You can create the app manually later or set the URI in .biolib/config.yml')
+        else:
+            print('App creation skipped. You can create the app manually later or set the URI in .biolib/config.yml')
+    except Exception as error:
+        print(f'Failed to validate app {app_uri}: {str(error)}')
+        print('Continuing with initialization...')
+
+    return True
+
+
+def _find_conflicting_files(template_dir: str, cwd: str) -> List[str]:
+    conflicting_files: List[str] = []
+    for root, dirs, filenames in os.walk(template_dir):
+        dirs[:] = [d for d in dirs if '__pycache__' not in d]
+        relative_dir = os.path.relpath(root, template_dir)
+        destination_dir = cwd if relative_dir == '.' else os.path.join(cwd, relative_dir)
+
+        for filename in filenames:
+            source_file = os.path.join(root, filename)
+            destination_file = os.path.join(destination_dir, filename)
+            if os.path.exists(destination_file):
+                with open(source_file, 'rb') as fsrc, open(destination_file, 'rb') as fdest:
+                    if fsrc.read() != fdest.read():
+                        conflicting_files.append(os.path.relpath(destination_file, cwd))
+    return conflicting_files
+
+
+def _prompt_for_overwrites(conflicting_files: List[str]) -> Set[str]:
+    files_to_overwrite: Set[str] = set()
+    if conflicting_files:
+        print('The following files already exist and would be overwritten:')
+        for conflicting_file in conflicting_files:
+            print(f'  {conflicting_file}')
+        print()
+
+        for conflicting_file in conflicting_files:
+            choice = input(f'Overwrite {conflicting_file}? [y/N]: ').lower().strip()
+            if choice in ['y', 'yes']:
+                files_to_overwrite.add(conflicting_file)
+    return files_to_overwrite
+
+
+def _copy_template_files(
+    template_dir: str,
+    cwd: str,
+    files_to_overwrite: Set[str],
+    replacements: Dict[str, str],
+) -> None:
+    for root, dirs, filenames in os.walk(template_dir):
+        dirs[:] = [d for d in dirs if '__pycache__' not in d]
+        relative_dir = os.path.relpath(root, template_dir)
+        destination_dir = os.path.join(cwd, relative_dir)
+
+        os.makedirs(destination_dir, exist_ok=True)
+
+        for filename in filenames:
+            if utils.BASE_URL_IS_PUBLIC_BIOLIB and filename == 'biolib.yml':
+                continue
+
+            source_file = os.path.join(root, filename)
+            destination_file = os.path.join(destination_dir, filename)
+            relative_file_path = os.path.relpath(destination_file, cwd)
+
+            if not os.path.exists(destination_file) or relative_file_path in files_to_overwrite:
+                try:
+                    with open(source_file) as f:
+                        content = f.read()
+
+                    new_content = content
+                    for old_value, new_value in replacements.items():
+                        new_content = new_content.replace(old_value, new_value)
+
+                    with open(destination_file, 'w') as f:
+                        f.write(new_content)
+                except UnicodeDecodeError:
+                    shutil.copy2(source_file, destination_file)
+
+
+def _create_readme_if_needed(cwd: str, app_name: Optional[str]) -> None:
+    readme_path = os.path.join(cwd, 'README.md')
+    if not os.path.exists(readme_path) and app_name:
+        with open(readme_path, 'w') as readme_file:
+            readme_file.write(f'# {app_name}\n')
+
+
+def _copy_gitignore(cwd: str) -> None:
+    gitignore_template_dir = templates.gitignore_template()
+    source_file = os.path.join(gitignore_template_dir, '.gitignore')
+    destination_file = os.path.join(cwd, '.gitignore')
+    if not os.path.exists(destination_file):
+        shutil.copy2(source_file, destination_file)
+
+
+def _copy_github_workflow(cwd: str, replacements: Dict[str, str]) -> None:
+    workflow_template_dir = templates.github_workflow_template()
+    source_file = os.path.join(workflow_template_dir, '.github', 'workflows', 'biolib.yml')
+    destination_dir = os.path.join(cwd, '.github', 'workflows')
+    destination_file = os.path.join(destination_dir, 'biolib.yml')
+
+    if not os.path.exists(destination_file):
+        os.makedirs(destination_dir, exist_ok=True)
+        with open(source_file) as f:
+            content = f.read()
+        for old_value, new_value in replacements.items():
+            content = content.replace(old_value, new_value)
+        with open(destination_file, 'w') as f:
+            f.write(content)
+
+
+def _prompt_and_run_yarn_install() -> None:
+    yarn_install_input = input('Do you want to run yarn install? [Y/n]: ')
+    if yarn_install_input.lower() not in ['n', 'no']:
+        print('Running yarn install...')
+        try:
+            subprocess.run(['yarn', 'install'], check=True)
+            print('yarn install completed successfully.')
+        except FileNotFoundError:
+            print(
+                'Error: yarn is not installed or not found in PATH. Please install yarn and run yarn install manually.'
+            )
+        except subprocess.CalledProcessError as error:
+            print(f'yarn install failed with exit code {error.returncode}. Please run yarn install manually.')
+        except Exception as error:
+            print(f'yarn install failed: {error}. Please run yarn install manually.')
+
+
+def _create_dashboard_dockerfile(cwd: str) -> None:
+    gui_template_dir = templates.gui_template()
+    gui_dockerfile = os.path.join(gui_template_dir, 'Dockerfile')
+    destination_file = os.path.join(cwd, 'Dockerfile')
+
+    if not os.path.exists(destination_file):
+        with open(gui_dockerfile) as f:
+            lines = f.readlines()
+
+        gui_builder_lines = []
+        for line in lines:
+            gui_builder_lines.append(line)
+            if line.strip() == 'RUN yarn build':
+                break
+
+        dist_export_stage = '\nFROM scratch AS dist_export\nCOPY --from=gui_builder /home/biolib/gui/dist /dist\n'
+        with open(destination_file, 'w') as f:
+            f.writelines(gui_builder_lines)
+            f.write(dist_export_stage)
+
+
+def _copy_gui_files_for_dashboard(cwd: str, app_name: str) -> None:
+    gui_template_dir = templates.gui_template()
+    gui_root_files = ['package.json', 'vite.config.mts', '.yarnrc.yml']
+
+    for root, _, filenames in os.walk(gui_template_dir):
+        relative_dir = os.path.relpath(root, gui_template_dir)
+
+        for filename in filenames:
+            if filename == 'Dockerfile':
+                continue
+
+            if filename in gui_root_files:
+                destination_dir = cwd
+            else:
+                if relative_dir == '.':
+                    destination_dir = os.path.join(cwd, 'gui')
+                else:
+                    destination_dir = os.path.join(cwd, 'gui', relative_dir)
+
+            source_file = os.path.join(root, filename)
+            destination_file = os.path.join(destination_dir, filename)
+
+            if not os.path.exists(destination_file):
+                os.makedirs(destination_dir, exist_ok=True)
+                try:
+                    with open(source_file) as f:
+                        content = f.read()
+                    new_content = content.replace('BIOLIB_REPLACE_APP_NAME', app_name)
+                    with open(destination_file, 'w') as f:
+                        f.write(new_content)
+                except UnicodeDecodeError:
+                    shutil.copy2(source_file, destination_file)
+
+
+def _init_dashboard() -> None:
+    if not _check_version_and_prompt_upgrade():
+        return
+
+    cwd = os.getcwd()
+    app_uri = _prompt_for_app_uri('What URI do you want to create the dashboard under? (leave blank to skip): ')
+    app_name = app_uri.split('/')[-1] if app_uri else None
+
+    if app_uri:
+        if not _validate_or_create_app(app_uri):
+            return
+    else:
+        print(
+            'Remember to set the app URI in the .biolib/config.yml file later, '
+            'and update the .github/workflows/biolib.yml file.'
+        )
+
+    dashboard_template_dir = templates.dashboard_template()
+
+    try:
+        conflicting_files = _find_conflicting_files(dashboard_template_dir, cwd)
+        files_to_overwrite = _prompt_for_overwrites(conflicting_files)
+
+        replace_app_uri = app_uri if app_uri else 'PUT_APP_URI_HERE'
+        replace_app_name = app_name if app_name else 'biolib-dashboard'
+
+        replacements = {
+            'BIOLIB_REPLACE_APP_URI': replace_app_uri,
+            'BIOLIB_REPLACE_APP_NAME': replace_app_name,
+        }
+
+        _copy_template_files(dashboard_template_dir, cwd, files_to_overwrite, replacements)
+        _create_readme_if_needed(cwd, app_name)
+        _copy_gitignore(cwd)
+        _copy_github_workflow(
+            cwd,
+            {
+                'BIOLIB_REPLACE_APP_URI': replace_app_uri,
+                'BIOLIB_REPLACE_BUILD_COMMAND': 'docker build --target dist_export -o type=local,dest=. .',
+            },
+        )
+        _create_dashboard_dockerfile(cwd)
+        _copy_gui_files_for_dashboard(cwd, replace_app_name)
+        _prompt_and_run_yarn_install()
+
+        print('Dashboard template initialized successfully.')
+
+    except KeyboardInterrupt:
+        print('\nInit command cancelled.', file=sys.stderr)
+        exit(1)
+
+
+@click.command(help='Initialize a BioLib project', hidden=True)
+@click.argument('template_type', required=False, default=None)
+def init(template_type: Optional[str]) -> None:
+    if template_type == 'dashboard':
+        _init_dashboard()
+        return
+
+    if template_type is not None:
+        print(f"Unknown template type: '{template_type}'. Available templates: dashboard")
+        print('Run `biolib init` without arguments for the default Python application template.')
+        return
+
+    if not _check_version_and_prompt_upgrade():
+        return
+
+    cwd = os.getcwd()
+    app_uri = _prompt_for_app_uri('What URI do you want to create the application under? (leave blank to skip): ')
+    app_name = app_uri.split('/')[-1] if app_uri else None
+    docker_tag = normalize_for_docker_tag(app_name) if app_name else None
+
+    if app_uri:
+        if not _validate_or_create_app(app_uri):
+            return
+    else:
+        print(
+            'Remember to set the app URI in the .biolib/config.yml file later, '
+            'and docker image name in the .biolib/config.yml and .github/workflows/biolib.yml files.'
+        )
+
+    advanced_setup_input = input('Do you want to set up advanced features like Copilot and GUI? [y/N]: ')
+    advanced_setup = advanced_setup_input.lower() == 'y'
+    include_copilot = False
+    include_gui = False
+    if advanced_setup:
+        copilot_enabled_input = input('Do you want to include Copilot instructions and prompts? [y/N]: ')
+        include_copilot = copilot_enabled_input.lower() == 'y'
+        include_gui_input = input('Do you want to include GUI setup? [y/N]: ')
+        include_gui = include_gui_input.lower() == 'y'
+
+    init_template_dir = templates.init_template()
+
+    try:
+        conflicting_files = _find_conflicting_files(init_template_dir, cwd)
+        files_to_overwrite = _prompt_for_overwrites(conflicting_files)
+
+        replace_app_uri = app_uri if app_uri else 'PUT_APP_URI_HERE'
+        replace_app_name = app_name if app_name else 'biolib-app'
+
+        gui_config = "main_output_file: '/result.html'\n" if include_gui else ''
+        gui_mv_command = 'mv result.html output/result.html\n' if include_gui else ''
+
+        replacements = {
+            'BIOLIB_REPLACE_PYBIOLIB_VERSION': BIOLIB_PACKAGE_VERSION,
+            'BIOLIB_REPLACE_APP_URI': replace_app_uri,
+            'BIOLIB_REPLACE_DOCKER_TAG': docker_tag if docker_tag else 'PUT_DOCKER_TAG_HERE',
+            'BIOLIB_REPLACE_APP_NAME': replace_app_name,
+            'BIOLIB_REPLACE_GUI_CONFIG\n': gui_config,
+            'BIOLIB_REPLACE_GUI_MV_COMMAND\n': gui_mv_command,
+        }
+
+        _copy_template_files(init_template_dir, cwd, files_to_overwrite, replacements)
+        _create_readme_if_needed(cwd, app_name)
+        _copy_gitignore(cwd)
+        build_tag = docker_tag if docker_tag else 'PUT_DOCKER_TAG_HERE'
+        _copy_github_workflow(
+            cwd,
+            {
+                'BIOLIB_REPLACE_APP_URI': replace_app_uri,
+                'BIOLIB_REPLACE_BUILD_COMMAND': f'docker build -t {build_tag}:latest .',
+            },
+        )
+
+        if include_copilot:
+            add_copilot_prompts(force=False, silent=True)
+
+        if include_gui:
+            add_gui_files(force=False, silent=True)
+            _prompt_and_run_yarn_install()
+
+    except KeyboardInterrupt:
+        print('\nInit command cancelled.', file=sys.stderr)
+        exit(1)

biolib/cli/lfs.py

@@ -0,0 +1,101 @@
+import json
+import logging
+import os
+import sys
+from typing import Dict, List
+
+import click
+
+from biolib import biolib_errors
+from biolib._data_record.data_record import DataRecord
+from biolib._internal.lfs import prune_lfs_cache
+from biolib.biolib_logging import logger, logger_no_user_data
+from biolib.typing_utils import Optional
+
+
+@click.group(help='Manage Large File Systems', hidden=True)
+def lfs() -> None:
+    pass
+
+
+@lfs.command(help='Create a Large File System')
+@click.argument('uri', required=True)
+def create(uri: str) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record create" instead.')
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    DataRecord.create(destination=uri)
+
+
+@lfs.command(help='Push a new version of a Large File System')
+@click.argument('uri', required=True)
+@click.option('--path', required=True, type=click.Path(exists=True))
+@click.option('--chunk-size', default=None, required=False, type=click.INT, help='The size of each chunk (In MB)')
+def push(uri: str, path: str, chunk_size: Optional[int]) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record update" instead.')
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    try:
+        DataRecord.get_by_uri(uri=uri).update(data_path=path, chunk_size_in_mb=chunk_size)
+    except biolib_errors.BioLibError as error:
+        print(f'An error occurred:\n{error.message}', file=sys.stderr)
+        exit(1)
+
+
+@lfs.command(help='Download a file from a Large File System')
+@click.argument('uri', required=True)
+@click.option('--file-path', required=True, type=str)
+def download_file(uri: str, file_path: str) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record download" instead.')
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    try:
+        record = DataRecord.get_by_uri(uri=uri)
+        try:
+            file_obj = [file_obj for file_obj in record.list_files() if file_obj.path == file_path][0]
+        except IndexError:
+            raise Exception('File not found in data record') from None
+
+        assert not os.path.exists(file_obj.name), 'File already exists in current directory'
+        with open(file_obj.name, 'wb') as file_handle:
+            file_handle.write(file_obj.get_data())
+
+    except biolib_errors.BioLibError as error:
+        print(f'An error occurred:\n{error.message}', file=sys.stderr)
+        exit(1)
+
+
+@lfs.command(help='Describe a Large File System')
+@click.argument('uri', required=True)
+@click.option('--json', 'output_as_json', is_flag=True, default=False, required=False, help='Format output as JSON')
+def describe(uri: str, output_as_json: bool) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record describe" instead.')
+    data_record = DataRecord.get_by_uri(uri)
+    files_info: List[Dict] = []
+    total_size_in_bytes = 0
+    for file in data_record.list_files():
+        files_info.append({'path': file.path, 'size_bytes': file.length})
+        total_size_in_bytes += file.length
+
+    if output_as_json:
+        print(
+            json.dumps(
+                obj={'uri': data_record.uri, 'size_bytes': total_size_in_bytes, 'files': files_info},
+                indent=4,
+            )
+        )
+    else:
+        print(f'Large File System {data_record.uri}\ntotal {total_size_in_bytes} bytes\n')
+        print('size bytes    path')
+        for file_info in files_info:
+            size_string = str(file_info['size_bytes'])
+            leading_space_string = ' ' * (10 - len(size_string))
+            print(f"{leading_space_string}{size_string}    {file_info['path']}")
+
+
+@lfs.command(help='Prune LFS cache', hidden=True)
+@click.option('--dry-run', type=click.BOOL, default=True, required=False)
+def prune_cache(dry_run: bool) -> None:
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    prune_lfs_cache(dry_run)

biolib/cli/push.py

@@ -0,0 +1,50 @@
+import logging
+import sys
+from typing import Optional
+
+import click
+
+from biolib._internal.errors import AuthenticationError
+from biolib._internal.push_application import push_application
+from biolib.biolib_logging import logger, logger_no_user_data
+
+
+@click.command(help='Push an application to BioLib')
+@click.argument('uri')
+@click.option('--path', default='.', required=False)
+@click.option('--copy-images-from-version', required=False)
+@click.option('--dev', is_flag=True, default=False, required=False)
+@click.option('--pre-release', is_flag=True, default=False, required=False)
+@click.option(
+    '--dry-run',
+    is_flag=True,
+    default=False,
+    required=False,
+    help='Perform validation without pushing',
+)
+def push(uri, path: str, copy_images_from_version: Optional[str], dev: bool, pre_release: bool, dry_run: bool) -> None:
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    set_as_active = True
+    set_as_published = True
+    if dev and pre_release:
+        print('Error: you cannot set both --dev and --pre-release, please select one.')
+        exit(1)
+    elif dev:
+        set_as_active = False
+        set_as_published = False
+    elif pre_release:
+        set_as_active = False
+        set_as_published = True
+    try:
+        push_application(
+            app_path=path,
+            app_uri=uri,
+            app_version_to_copy_images_from=copy_images_from_version,
+            set_as_active=set_as_active,
+            set_as_published=set_as_published,
+            dry_run=dry_run,
+        )
+    except AuthenticationError as error:
+        print(error.message, file=sys.stderr)
+        exit(1)

biolib/cli/run.py

@@ -0,0 +1,63 @@
+import sys
+
+import click
+
+from biolib import biolib_errors, utils
+from biolib.app import BioLibApp
+from biolib.experiments.experiment import Experiment
+from biolib.typing_utils import Optional, Tuple
+
+
+@click.command(
+    context_settings=dict(ignore_unknown_options=True, allow_interspersed_args=False),
+    help='Run an application on BioLib.',
+)
+@click.option('--experiment', type=str, required=False, help='Experiment name or URI to add the run to.')
+@click.option('--local', is_flag=True, required=False, hidden=True)
+@click.option('--non-blocking', is_flag=True, required=False, help='Run the application non blocking.')
+@click.argument('uri', required=True)
+@click.argument('args', nargs=-1, type=click.UNPROCESSED)
+def run(experiment: Optional[str], local: bool, non_blocking: bool, uri: str, args: Tuple[str]) -> None:
+    if local:
+        print('Error: Running applications locally with --local is no longer supported.', file=sys.stderr)
+        sys.exit(1)
+
+    if experiment:
+        with Experiment(uri=experiment):
+            _run(non_blocking=non_blocking, uri=uri, args=args)
+    else:
+        _run(non_blocking=non_blocking, uri=uri, args=args)
+
+
+def _run(non_blocking: bool, uri: str, args: Tuple[str]) -> None:
+    try:
+        app = BioLibApp(uri=uri)
+    except biolib_errors.BioLibError as error:
+        print(f'An error occurred:\n {error.message}', file=sys.stderr)
+        exit(1)
+
+    def _get_stdin():
+        stdin = None
+        if not sys.stdin.isatty() and not utils.IS_DEV:
+            stdin = sys.stdin.read()
+        return stdin
+
+    blocking = not non_blocking
+    job = app.cli(
+        args=list(args),
+        stdin=_get_stdin(),
+        files=None,
+        blocking=blocking,
+    )
+
+    if blocking:
+        job.save_files('biolib_results', overwrite=True)
+
+        # Write stdout and stderr if it has not been streamed (Markdown is not streamed)
+        if app.version.get('stdout_render_type') == 'markdown' or not sys.stdout.isatty():
+            sys.stdout.buffer.write(job.get_stdout())
+            sys.stderr.buffer.write(job.get_stderr())
+
+        exit(job.get_exit_code())
+    else:
+        print('{"job_id": "' + str(job.id) + '"}')

biolib/cli/runtime.py

@@ -0,0 +1,14 @@
+import click
+
+import biolib.runtime
+
+
+@click.group(help='Commands available within a BioLib runtime')
+def runtime() -> None:
+    pass
+
+
+@runtime.command(help='Set the name prefix of the main result')
+@click.argument('result-prefix', required=True)
+def set_main_result_prefix(result_prefix: str) -> None:
+    biolib.runtime.set_main_result_prefix(result_prefix)

biolib/cli/sdk.py

@@ -0,0 +1,16 @@
+import click
+
+from biolib._internal.add_copilot_prompts import add_copilot_prompts
+
+
+@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_command(force: bool) -> None:
+    add_copilot_prompts(force)