pybiolib 1.2.802__py3-none-any.whl → 1.2.814__py3-none-any.whl

biolib/_internal/llm_instructions/.github/instructions/general-app-knowledge.instructions.md

@@ -0,0 +1,10 @@
+---
+applyTo: "**"
+---
+
+You are writing code that runs inside a BioLib app. In general, most BioLib apps are structured such that there is a `run.py` or `main.py` file that contains the main function.
+Other files are usually helper files that contain functions that are called from the main function.
+
+BioLib apps often contain a Vite React Typescript project that compiles to a single HTML file used to render interactive and visual output.
+
+BioLib apps run inside a Docker container, which is built from the `Dockerfile` in the root of the app.

biolib/_internal/llm_instructions/.github/instructions/style-general.instructions.md

@@ -0,0 +1,15 @@
+---
+applyTo: '**'
+---
+
+# General Coding Guidelines
+- Variable names are allowed to be verbose, and should be descriptive.
+- 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.
+- Function definitions should be typed as specifically as possible.
+
+# Code Comment Guidelines
+- Code comments should only be added for complex logic or unintuitive code that is not adequately explained by the function names themselves.
+- Avoid comments that simply restate what the code does.
+- When writing comments explaining some non-trivial logic, explain blocks of code rather than individual lines.
+- Explain changes to the code in chat, not in comments.

biolib/_internal/llm_instructions/.github/instructions/style-python.instructions.md

@@ -0,0 +1,16 @@
+---
+applyTo: '**/*.py'
+---
+
+Apply the [general coding guidelines](./style-general.instructions.md) to all code.
+
+# Python-specific code style guidelines
+- Use snake_case for function and variable names, and PascalCase for class names.
+- Place all imports at the top of the file, grouped in the following order: standard library imports, third-party imports, local application imports. Separate each group with a blank line.
+- Limit all lines to a maximum of 120 characters.
+- Prefer single quotes for strings unless the string contains a single quote, in which case use double quotes.
+- Use blank lines to separate functions, class definitions, and logical sections within functions.
+- Use type hints for function arguments and return values where possible.
+- Use docstrings to document functions that are used in the main python script, but not elsewhere.
+- Avoid using bare except clauses; always specify the exception being caught.
+- Use list comprehensions and generator expressions where appropriate for clarity and conciseness.

biolib/_internal/llm_instructions/.github/instructions/style-react-ts.instructions.md

@@ -0,0 +1,22 @@
+---
+applyTo: "**/*.ts,**/*.tsx"
+---
+
+Apply the [general coding guidelines](./style-general.instructions.md) to all code.
+
+# General Project Guidelines
+- Use yarn instead of npm whenever relevant.
+- Prefer using `export default function` over exporting at the end of the file.
+
+# TypeScript Guidelines
+- Use TypeScript for all new code
+- Follow functional programming principles where possible
+- Use interfaces for data structures prefixed with I like `interface IRecord`
+- Prefer immutable data (const, readonly)
+- Use optional chaining (?.) and nullish coalescing (??) operators
+
+# React Guidelines
+- Use functional components with hooks
+- Follow the React hooks rules (no conditional hooks)
+- Prefer one component per file
+- Use Tailwindcss for styling

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

@@ -1,60 +1,11 @@
+---
+mode: 'agent'
+tools: ['codebase', 'fetch']
+description: 'Handle changing inputs for a biolib app, by adding, removing or modifying inputs in the config.yml and the python script.'
+---
+
 # 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.
+Read the documentation [here](https://biolib.com/docs/building-applications/syntax-of-config-yml/) to understand how the inputs are handled in the config.yml file.
+Inputs in the Python script should be parsed with argparse. If a default is given in the config.yml file, it it is not necessary to set a default in the Python script.
+Otherwise, the two files should be consistent.

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

@@ -1,302 +1,12 @@
-# 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')
+---
+mode: 'agent'
+tools: ['githubRepo', 'codebase', 'fetch']
+description: 'Handle running biolib apps, including login, running apps, and managing jobs and results.'
+---
+
+# Main task
+Your task is to run one or more biolib apps, using the biolib Python API. You can find general instructions [here](https://biolib.com/docs/using-applications/python/)
+A few relevant notes:
+- You will be running this from inside a biolib app, so login is not necessary.
+- Always look at the relevant app's #githubRepo. Ask the user for the repo, and inform them that it needs to be in the format `author/app_name`.
+- If you do look at the repo, look at the config.yml to see how it expects inputs to be formatted.

{pybiolib-1.2.802.dist-info → pybiolib-1.2.814.dist-info}/METADATA

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

{pybiolib-1.2.802.dist-info → pybiolib-1.2.814.dist-info}/RECORD

@@ -14,10 +14,12 @@ 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/instructions/code-style.md,sha256=6epb7p2d0am-nS9WnnncYIiLzqnoXmJySbS7Y9sTUv8,475
-biolib/_internal/llm_instructions/.github/instructions/copilot-instructions.md,sha256=4zoTs_xCV7UxmFfi2VDETMVUlDdMdGxp4FpNn4IHAxI,366
-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/.github/instructions/general-app-knowledge.instructions.md,sha256=-j8v0GRtDhHoqP2wcGUykiwU7HQ0DmkCNxw_01oKMdY,546
+biolib/_internal/llm_instructions/.github/instructions/style-general.instructions.md,sha256=tl2Ve1ZPlPBrH6CSrjIkiMA8xnM2tQIJs1cerKCyAkU,761
+biolib/_internal/llm_instructions/.github/instructions/style-python.instructions.md,sha256=xfypuPqMsz5ejobDoVI0HjmNqksl16aFuIol1nAhpHg,1034
+biolib/_internal/llm_instructions/.github/instructions/style-react-ts.instructions.md,sha256=GQoRL-bfPwwNIW4W0yN_guVIqFNVCG2_7adOCaxiz-w,755
+biolib/_internal/llm_instructions/.github/prompts/biolib_app_inputs.prompt.md,sha256=SMzXZImdID0yKjhE1fG54VrHdD8IVuwRxRKsMF-KjWs,697
+biolib/_internal/llm_instructions/.github/prompts/biolib_run_apps.prompt.md,sha256=-t1bmGr3zEFa6lKHaLcI98yq4Sg1TCMW8xbelNSHaOA,696
 biolib/_internal/llm_instructions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/_internal/push_application.py,sha256=I7yHGcwK6udc2hVmOQIc1BcQBipAMibEjURMI6HgdXk,12502
 biolib/_internal/runtime.py,sha256=BiHl4klUHr36MCpqKaUso4idHeBZfPAahLYRQrabFqA,486
@@ -131,8 +133,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.802.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
-pybiolib-1.2.802.dist-info/METADATA,sha256=Sad2f-bZHF7jI1ZQCubwERfK_5mgPsn486KleIAzG8Q,1570
-pybiolib-1.2.802.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-pybiolib-1.2.802.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
-pybiolib-1.2.802.dist-info/RECORD,,
+pybiolib-1.2.814.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+pybiolib-1.2.814.dist-info/METADATA,sha256=dkiANMd2NxMszfRSRvCAlAxPS-3Eas0SQAdzGs_8yOc,1570
+pybiolib-1.2.814.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+pybiolib-1.2.814.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
+pybiolib-1.2.814.dist-info/RECORD,,

biolib/_internal/llm_instructions/.github/instructions/code-style.md

@@ -1,13 +0,0 @@
----
-applyTo: '**'
----
-
-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.
-
-Function definitions should be typed as specifically as possible.

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

@@ -1,9 +0,0 @@
----
-applyTo: '**'
----
-
-Use yarn instead of npm whenever relevant.
-
-When running BioLib Apps, use [this file](../prompts/biolib_run_apps.prompt.md) as context to understand how that works.
-
-When working with BioLib App inputs, use [this file](../prompts/biolib_app_inputs.prompt.md) as context to understand how the different files should be connected and formatted.