# packages

pkgId: 28d622258b8347048a42c6312fca3eacc985ee07ee0f226752667869ea3c4f18
name: python-bioimageio.spec
arch: src
version: 0.5.3.5
epoch: 0
release: 1
summary: Parser and validator library for bioimage.io specifications
url: https://github.com/bioimage-io/spec-bioimage-io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioimageio.spec-0.5.3.5-1.src.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/github/license/bioimage-io/spec-bioimage-io.svg)
  [![PyPI](https://img.shields.io/pypi/v/bioimageio-spec.svg?style=popout)](https://pypi.org/project/bioimageio.spec/)
  [![conda-version](https://anaconda.org/conda-forge/bioimageio.spec/badges/version.svg)](https://anaconda.org/conda-forge/bioimageio.spec/)
  [![downloads](https://static.pepy.tech/badge/bioimageio.spec)](https://pepy.tech/project/bioimageio.spec)
  [![conda-forge downloads](https://img.shields.io/conda/dn/conda-forge/bioimageio.spec.svg?label=conda-forge)](https://anaconda.org/conda-forge/bioimageio.spec/)
  ![code style](https://img.shields.io/badge/code%20style-black-000000.svg)
  [![coverage](https://bioimage-io.github.io/spec-bioimage-io/coverage/coverage-badge.svg)](https://bioimage-io.github.io/spec-bioimage-io/coverage/index.html)



  This repository contains the specifications of the standard format defined by the bioimage.io community for the content (i.e., models, datasets and applications) in the [bioimage.io website](https://bioimage.io).
  Each item in the content is always described using a YAML 1.2 file named `rdf.yaml` or `bioimageio.yaml`.
  This `rdf.yaml` \ `bioimageio.yaml`--- along with the files referenced in it --- can be downloaded from or uploaded to the [bioimage.io website](https://bioimage.io) and may be produced or consumed by bioimage.io-compatible consumers (e.g., image analysis software like ilastik).

  [These](https://github.com/bioimage-io/spec-bioimage-io?tab=readme-ov-file#format-version-overview) are the rules and format that bioimage.io-compatible resources must fulfill.

  Note that the Python package PyYAML does not support YAML 1.2 .
  We therefore use and recommend [ruyaml](https://ruyaml.readthedocs.io/en/latest/).
  For differences see <https://ruamelyaml.readthedocs.io/en/latest/pyyaml>.

  Please also note that the best way to check whether your `rdf.yaml` file is bioimage.io-compliant is to call `bioimageio.core.validate` from the [bioimageio.core](https://github.com/bioimage-io/core-bioimage-io-python) Python package.
  The [bioimageio.core](https://github.com/bioimage-io/core-bioimage-io-python) Python package also provides the bioimageio command line interface (CLI) with the `validate` command:

  ```terminal
  bioimageio validate path/to/your/rdf.yaml
  ```



  All bioimage.io description formats are defined as [Pydantic models](https://docs.pydantic.dev/latest/).

  | type | format version | documentation |
  | --- | --- | --- |
  | model | 0.5 </br> 0.4 | [model_descr_v0-5.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/model_descr_v0-5.md) </br> [model_descr_v0-4.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/model_descr_v0-4.md) |
  | dataset | 0.3 </br> 0.2 | [dataset_descr_v0-3.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/dataset_descr_v0-3.md) </br> [dataset_descr_v0-2.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/dataset_descr_v0-2.md) |
  | notebook | 0.3 </br> 0.2 | [notebook_descr_v0-3.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/notebook_descr_v0-3.md) </br> [notebook_descr_v0-2.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/notebook_descr_v0-2.md) |
  | application | 0.3 </br> 0.2 | [application_descr_v0-3.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/application_descr_v0-3.md) </br> [application_descr_v0-2.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/application_descr_v0-2.md) |
  | collection | 0.3 </br> 0.2 | [collection_descr_v0-3.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/collection_descr_v0-3.md) </br> [collection_descr_v0-2.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/collection_descr_v0-2.md) |
  | generic | 0.3 </br> 0.2 | [generic_descr_v0-3.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/generic_descr_v0-3.md) </br> [generic_descr_v0-2.md](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/user_docs/generic_descr_v0-2.md) |



  Simplified descriptions are available as [JSON schema](https://json-schema.org/):

  | bioimageio.spec version | JSON schema |
  | --- | --- |
  | latest | [bioimageio_schema_latest.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_latest.json) ([documentation (WIP)](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html)) |
  | 0.5 | [bioimageio_schema_v0-5.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_v0-5.json) ([documentation (WIP)](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_v0-5/index.html)) |

  These are primarily intended for syntax highlighting.



  A flattened view of the types used by the spec that also shows values constraints.

  [rendered](https://bioimage-io.github.io/spec-bioimage-io/interactive_docs_v0-5.html)

  You can also generate these docs locally by running `PYTHONPATH=./scripts python -m interactive_docs`



  We provide some [examples for using rdf.yaml files to describe models, applications, notebooks and datasets](https://github.com/bioimage-io/spec-bioimage-io/blob/main/example_descriptions/examples.md),
  and an [example notebook to programmatically access the models, applications, notebooks and datasets descriptions](https://github.com/bioimage-io/spec-bioimage-io/blob/main/example/load_model_and_create_your_own.ipynb).



  * Due to the limitations of storage services such as Zenodo, which does not support subfolders, it is recommended to place other files in the same directory level of the `rdf.yaml` file and try to avoid using subdirectories.
  * Use the [bioimageio.core Python package](https://github.com/bioimage-io/core-bioimage-io-python) to validate your `rdf.yaml` file.
  * bioimageio.spec keeps evolving. Try to use and upgrade to the most current format version!



  The bioimageio CLI has moved entirely to [bioimageio.core](https://github.com/bioimage-io/core-bioimage-io-python).



  bioimageio.spec can be installed with either `conda` or `pip`.
  We recommend installing `bioimageio.core` instead to get access to the Python programmatic features available in the BioImage.IO community:

  ```console
  conda install -c conda-forge bioimageio.core
  ```

  or

  ```console
  pip install -U bioimageio.core
  ```

  Still, for a lighter package or just testing, you can install the `bioimageio.spec` package solely:

  ```console
  conda install -c conda-forge bioimageio.spec
  ```

  or

  ```console
  pip install -U bioimageio.spec
  ```



  TODO: link to settings in dev docs





  <a href="https://github.com/bioimage-io/spec-bioimage-io/graphs/contributors">
    <img alt="bioimageio.spec contributors" src="https://contrib.rocks/image?repo=bioimage-io/spec-bioimage-io" />
  </a>

  Made with [contrib.rocks](https://contrib.rocks).



  To keep the bioimageio.spec Python package version in sync with the (model) description format version, bioimageio.spec is versioned as MAJOR.MINRO.PATCH.LIB, where MAJOR.MINRO.PATCH correspond to the latest model description format version implemented and LIB may be bumpbed for library changes that do not affect the format version.
  [This change was introduced with bioimageio.spec 0.5.3.1](#bioimageiospec-0531).







  * fix loading tifffile in python 3.8 (pin tifffile)
  * use default tensorflow environments for Keras H5 weights



  * support loading and saving from/to zipfile.ZipFile objects
  * fix bug when packaging with weights priority order (#638)
  * add conda_env module providing helper to create recommended conda environments for model descriptions
  * fix summary formatting
  * improve logged origin for logged messages
  * make the `model.v0_5.ModelDescr.training_data` field a `left_to_right` Union to avoid warnings
  * the deprecated `version_number` is no longer appended to the `id`, but instead set as `version` if no `version` is specified.



  * expose `progressbar` to customize display of download progress
  * expose `get_resource_package_content`
  * prefer `rdf.yaml` over `bioimageio.yaml` (name `bioimageio.yaml` file `rdf.yaml` file when packaging, look for `rdf.yaml` first, etc.)
  * enforce: (generic 0.3/model 0.5 spec) documentation source file encoding has to be UTF-8.
  * bugfix: allow optional pre- and postprocessing to be missing in an RDF (before it required an empty dict).



  * bugfix "reset known files if root changes" (#619)



  note: the versioning scheme was changed as our previous `post` releases include changes beyond what a post release should entail (only changing docstrings, etc).
  This was motivated by the desire to keep the library version in sync with the (model) format version to avoid confusion.
  To keep this relation, but avoid overbearing post releases a library version number is now added as the 4th part MAJOR.MINOR.PATCH.LIB_VERSION.

  * add `load_model_description` and `load_dataset_description`
  * add `ensure_description_is_model` and `ensure_description_is_dataset`
  * expose `perform_io_checks` and `known_files` from `ValidationContext` to `load_description` and `load_description_and_validate_format_only`



  * fix pinning of pydantic



  * update resolving of bioimage.io resource IDs



  * fix SHA-256 value when resolving a RDF version from the bioimage.io collection that is not the latest



  * bump patch version during loading for model 0.5.x
  * improve validation error formatting
  * validate URLs first with a head request, if forbidden, follow up with a get request that is streamed and if that is also forbidden a regular get request.
  * `RelativePath.absolute()` is now a method (not a property) analog to `pathlib.Path`



  * remove collection description
  * update SPDX license list
  * update generic description to 0.3.1
  * update model description to 0.5.3
  * add timeout argument to all requests.get calls



  * added more information to validation summary
  * deprioritize `Path` objects in the `FileSource` union



  * resolve backup DOIs
  * fix resolving relative file paths given as strings
  * allow to bypass download and hashing of known files



  * avoid full download when validating urls



  * resolve version (un)specific collection IDs, e.g. `load_description('affable-shark')`, `load_description('affable-shark/1')`



  * fix model packaging with weights format priority



  * new patch version model 0.5.2



  * new patch version model 0.5.1



  * don't fail if CI env var is a string



  * fix `_internal.io_utils.identify_bioimageio_yaml_file()`



  * new description formats: [generic 0.3, application 0.3, collection 0.3, dataset 0.3, notebook 0.3](generic-030--application-030--collection-030--dataset-030--notebook-030) and [model 0.5](model-050).
  * various API changes, most important functions:
    * `bioimageio.spec.load_description` (replaces `load_raw_resource_description`, interface changed)
    * `bioimageio.spec.validate_format` (new)
    * `bioimageio.spec.dump_description` (replaces `serialize_raw_resource_description_to_dict`, interface changed)
    * `bioimageio.spec.update_format` (interface changed)
  * switch from Marshmallow to Pydantic
    * extended validation
    * one joint, more precise JSON schema



  * small bugixes
  * better type hints
  * improved tests



  * add `axes` and `eps` to `scale_mean_var`



  * add simple forward compatibility by treating future format versions as latest known (for the respective resource type)



  * Make CLI output more readable

  * find redirected URLs when checking for URL availability



  * Improve error message for non-existing RDF file path given as string

  * Improve documentation for model description's `documentation` field



  * fix enrich_partial_rdf_with_imjoy_plugin (see <https://github.com/bioimage-io/spec-bioimage-io/pull/452>)



  * fix rdf_update of entries in `resolve_collection_entries()`



  * pass root to `enrich_partial_rdf` arg of `resolve_collection_entries()`



  * keep `ResourceDescrption.root_path` as URI for remote resources. This fixes the collection description as the collection entries are resolved after the collection description has been loaded.



  * new bioimageio.spec.partner module adding validate-partner-collection command if optional 'lxml' dependency is available



  * new env var `BIOIMAGEIO_CACHE_WARNINGS_LIMIT` (default: 3) to avoid spam from cache hit warnings

  * more robust conversion of ImportableSourceFile for absolute paths to relative paths (don't fail on non-path source file)



  * resolve symlinks when transforming absolute to relative paths during serialization; see [#438](https://github.com/bioimage-io/spec-bioimage-io/pull/438)



  * fix loading of collection description with id (id used to be ignored)



  * support loading bioimageio resources by their animal nickname (currently only models have nicknames).



  * any field previously expecting a local relative path is now also accepting an absolute path

  * load_raw_resource_description returns a raw resource description which has no relative paths (any relative paths are converted to absolute paths).



  * add command `commands.update_rdf()`/`update-rdf`(cli)



  * fix unresolved ImportableSourceFile



  * fix collection description conversion for type field



  * fix to shape validation for model description 0.4: output shape now needs to be bigger than halo

  * moved objects from bioimageio.spec.shared.utils to bioimageio.spec.shared\[.node_transformer\]
  * additional keys to validation summary: bioimageio_spec_version, status



  * fixes to generic description:
    * ignore value of field `root_path` if present in yaml. This field is used internally and always present in RDF nodes.



  * fixes to collection description:
    * RDFs specified directly in collection description are validated correctly even if their source field does not point to an RDF.
    * nesting of collection description allowed



  * fixed missing field `icon` in generic description's raw node

  * fixes to collection description:
    * RDFs specified directly in collection description are validated correctly
    * no nesting of collection description allowed for now
    * `links` is no longer an explicit collection entry field ("moved" to unknown)



  * new model spec 0.3.5 and 0.4.1



  * `load_raw_resource_description` no longer accepts `update_to_current_format` kwarg (use `update_to_format` instead)



  * `load_raw_resource_description` accepts `update_to_format` kwarg





  * Non-breaking changes
    * remove `version_number` in favor of using `version`



  * Non-breaking changes
    * added `concatenable` flag to index, time and space input axes



  * Non-breaking changes
    * added `DataDependentSize` for `outputs.i.size` to specify an output shape that is not known before inference is run.
    * added optional `inputs.i.optional` field to indicate that a tensor may be `None`
    * made data type assumptions in `preprocessing` and `postprocessing` explicit by adding `'ensure_dtype'` operations per default.
    * allow to specify multiple thresholds (along an `axis`) in a 'binarize' processing step



  * Breaking canges that are fully auto-convertible
    * dropped `download_url`
    * dropped non-file attachments
    * `attachments.files` moved to `attachments.i.source`
  * Non-breaking changes
    * added optional `parent` field



  all generic 0.3.0 changes (except models already have the `parent` field) plus:

  * Breaking changes that are partially auto-convertible
    * `inputs.i.axes` are now defined in more detail (same for `outputs.i.axes`)
    * `inputs.i.shape` moved per axes to `inputs.i.axes.size` (same for `outputs.i.shape`)
    * new pre-/postprocessing 'fixed_zero_mean_unit_variance' separated from 'zero_mean_unit_variance', where `mode=fixed` is no longer valid.
      (for scalar values this is auto-convertible.)
  * Breaking changes that are fully auto-convertible
    * changes in `weights.pytorch_state_dict.architecture`
      * renamed `weights.pytorch_state_dict.architecture.source_file` to `...architecture.source`
    * changes in `weights.pytorch_state_dict.dependencies`
      * only conda environment allowed and specified by `weights.pytorch_state_dict.dependencies.source`
      * new optional field `weights.pytorch_state_dict.dependencies.sha256`
    * changes in `weights.tensorflow_model_bundle.dependencies`
      * same as changes in `weights.pytorch_state_dict.dependencies`
    * moved `test_inputs` to `inputs.i.test_tensor`
    * moved `test_outputs` to `outputs.i.test_tensor`
    * moved `sample_inputs` to `inputs.i.sample_tensor`
    * moved `sample_outputs` to `outputs.i.sample_tensor`
    * renamed `inputs.i.name` to `inputs.i.id`
    * renamed `outputs.i.name` to `outputs.i.id`
    * renamed `inputs.i.preprocessing.name` to `inputs.i.preprocessing.id`
    * renamed `outputs.i.postprocessing.name` to `outputs.i.postprocessing.id`
  * Non-breaking changes:
    * new pre-/postprocessing: `id`='ensure_dtype' with kwarg `dtype`



  * Breaking changes that are fully auto-convertible
    * `id` overwritten with value from `config.bioimageio.nickname` if available
  * Non-breaking changes
    * `version_number` is a new, optional field indicating that an RDF is the nth published version with a given `id`
    * `id_emoji` is a new, optional field (set from `config.bioimageio.nickname_icon` if available)
    * `uploader` is a new, optional field with `email` and an optional `name` subfields



  * Non-breaking changes
    * make pre-/postprocessing kwargs `mode` and `axes` always optional for model description 0.3 and 0.4



  * Non-breaking changes
    * `cite` field is now optional



  * Breaking changes that are fully auto-convertible
    * name field may not include '/' or '\' (conversion removes these)



  * Non-breaking changes
    * Implicit output shape can be expanded by inserting `null` into `shape:scale` and indicating length of new dimension D in the `offset` field. Keep in mind that `D=2*'offset'`.



  * Breaking changes that are fully auto-convertible
    * `parent` field changed to hold a string that is a bioimage.io ID, a URL or a local relative path (and not subfields `uri` and `sha256`)



  * Non-breaking changes
    * new optional field `training_data`



  * Non-breaking changes
    * explicitly define and document dataset description (for now, clone of generic description with type="dataset")



  * Non-breaking changes
    * add optional field `download_url`
    * add optional field `dependencies` to all weight formats (not only pytorch_state_dict)
    * add optional `pytorch_version` to the pytorch_state_dict and torchscript weight formats



  * Bug fixes:
    * in a `pytorch_state_dict` weight entry `architecture` is no longer optional.



  * Non-breaking changes
    * make `authors`, `cite`, `documentation` and `tags` optional

  * Breaking changes that are fully auto-convertible
    * Simplifies collection description 0.2.1 by merging resource type fields together to a `collection` field,
      holindg a list of all resources in the specified collection.



  * Non-breaking changes
    * `rdf_source` new optional field
    * `id` new optional field



  * First official release, extends generic description with fields `application`, `model`, `dataset`, `notebook` and (nested)
    `collection`, which hold lists linking to respective resources.



  * Non-breaking changes
    * add optional `email` and `github_user` fields to entries in `authors`
    * add optional `maintainers` field (entries like in `authors` but  `github_user` is required (and `name` is not))



  * Breaking changes that are fully auto-convertible
    * moved field `dependencies` to `weights:pytorch_state_dict:dependencies`

  * Non-breaking changes
    * `documentation` field accepts URLs as well



  * Non-breaking changes
    * `documentation` field accepts URLs as well



  * Breaking changes
    * model inputs and outputs may not use duplicated names.
    * model field `sha256` is required if `pytorch_state_dict` weights are defined.
      and is now moved to the `pytroch_state_dict` entry as `architecture_sha256`.

  * Breaking changes that are fully auto-convertible
    * model fields language and framework are removed.
    * model field `source` is renamed `architecture` and is moved together with `kwargs` to the `pytorch_state_dict`
      weights entry (if it exists, otherwise they are removed).
    * the weight format `pytorch_script` was renamed to `torchscript`.
  * Other changes
    * model inputs (like outputs) may be defined by `scale`ing and `offset`ing a `reference_tensor`
    * a `maintainers` field was added to the model description.
    * the entries in the `authors` field may now additionally contain `email` or `github_user`.
    * the summary returned by the `validate` command now also contains a list of warnings.
    * an `update_format` command was added to aid with updating older RDFs by applying auto-conversion.



  * Non-breaking changes
    * Add optional parameter `eps` to `scale_range` postprocessing.



  * Breaking changes that are fully auto-convertible
    * `reference_input` for implicit output tensor shape was renamed to `reference_tensor`



  * Breaking changes
    * The RDF file name in a package should be `rdf.yaml` for all the RDF (not `model.yaml`);
    * Change `authors` and `packaged_by` fields from List[str] to List[Author] with Author consisting of a dictionary `{name: '<Full name>', affiliation: '<Affiliation>', orcid: 'optional orcid id'}`;
    * Add a mandatory `type` field to comply with the generic description. Only valid value is 'model' for model description;
    * Only allow `license` identifier from the [SPDX license list](https://spdx.org/licenses/);

  * Non-breaking changes
    * Add optional `version` field (default 0.1.0) to keep track of model changes;
    * Allow the values in the `attachments` list to be any values besides URI;


pkgId: e756bca48c53ba2ee4f7edbd20b3190550e8fc676e0cc814959283edab191ff4
name: python-bioimageio.spec
arch: src
version: 0.5.3.6
epoch: 0
release: 1
summary: Parser and validator library for bioimage.io specifications
url: https://github.com/bioimage-io/spec-bioimage-io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioimageio.spec-0.5.3.6-1.src.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/github/license/bioimage-io/spec-bioimage-io.svg)
  [![PyPI](https://img.shields.io/pypi/v/bioimageio-spec.svg?style=popout)](https://pypi.org/project/bioimageio.spec/)
  [![conda-version](https://anaconda.org/conda-forge/bioimageio.spec/badges/version.svg)](https://anaconda.org/conda-forge/bioimageio.spec/)
  [![downloads](https://static.pepy.tech/badge/bioimageio.spec)](https://pepy.tech/project/bioimageio.spec)
  [![conda-forge downloads](https://img.shields.io/conda/dn/conda-forge/bioimageio.spec.svg?label=conda-forge)](https://anaconda.org/conda-forge/bioimageio.spec/)
  ![code style](https://img.shields.io/badge/code%20style-black-000000.svg)
  [![coverage](https://bioimage-io.github.io/spec-bioimage-io/coverage/coverage-badge.svg)](https://bioimage-io.github.io/spec-bioimage-io/coverage/index.html)



  This repository contains the specifications of the standard format defined by the bioimage.io community for the content (i.e., models, datasets and applications) in the [bioimage.io website](https://bioimage.io).
  Each item in the content is always described using a YAML 1.2 file named `rdf.yaml` or `bioimageio.yaml`.
  This `rdf.yaml` \ `bioimageio.yaml`--- along with the files referenced in it --- can be downloaded from or uploaded to the [bioimage.io website](https://bioimage.io) and may be produced or consumed by bioimage.io-compatible consumers (e.g., image analysis software like ilastik).

  [These](https://github.com/bioimage-io/spec-bioimage-io?tab=readme-ov-file#format-version-overview) are the rules and format that bioimage.io-compatible resources must fulfill.

  Note that the Python package PyYAML does not support YAML 1.2 .
  We therefore use and recommend [ruyaml](https://ruyaml.readthedocs.io/en/latest/).
  For differences see <https://ruamelyaml.readthedocs.io/en/latest/pyyaml>.

  Please also note that the best way to check whether your `rdf.yaml` file is bioimage.io-compliant is to call `bioimageio.core.validate` from the [bioimageio.core](https://github.com/bioimage-io/core-bioimage-io-python) Python package.
  The [bioimageio.core](https://github.com/bioimage-io/core-bioimage-io-python) Python package also provides the bioimageio command line interface (CLI) with the `validate` command:

  ```terminal
  bioimageio validate path/to/your/rdf.yaml
  ```



  All bioimage.io description formats are defined as [Pydantic models](https://docs.pydantic.dev/latest/).

  | Type | Format Version | Documentation[^1] | Developer Documentation[^2] |
  | --- | --- | --- | --- |
  | model | 0.5 </br> 0.4 | [model 0.5](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i2_oneOf_i1) </br> [model 0.4](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i2_oneOf_i0) | [ModelDescr_v0_5](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/model/v0_5.html#ModelDescr) </br> [ModelDescr_v0_4](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/model/v0_4.html#ModelDescr) |
  | dataset | 0.3 </br> 0.2 | [dataset 0.3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i1_oneOf_i1) </br> [dataset 0.2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i1_oneOf_i0) | [DatasetDescr_v0_3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/dataset/v0_3.html#DatasetDescr) </br> [DatasetDescr_v0_2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/dataset/v0_2.html#DatasetDescr) |
  | notebook | 0.3 </br> 0.2 | [notebook 0.3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i3_oneOf_i1) </br> [notebook 0.2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i3_oneOf_i0) | [NotebookDescr_v0_3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/notebook/v0_3.html#NotebookDescr) </br> [NotebookDescr_v0_2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/notebook/v0_2.html#NotebookDescr) |
  | application | 0.3 </br> 0.2 | [application 0.3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i0_oneOf_i1) </br> [application 0.2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html#oneOf_i0_oneOf_i0) | [ApplicationDescr_v0_3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/application/v0_3.html#ApplicationDescr) </br> [ApplicationDescr_v0_2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/application/v0_2.html#ApplicationDescr) |
  | generic | 0.3 </br> 0.2 | - | [GenericDescr_v0_3](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/generic/v0_3.html#GenericDescr) </br> [GenericDescr_v0_2](https://bioimage-io.github.io/spec-bioimage-io/bioimageio/spec/generic/v0_2.html#GenericDescr) |

  [^1]: JSON Schema based documentation generated with [json-schema-for-humans](https://coveooss.github.io/json-schema-for-humans/).
  [^2]: Part of the bioimageio.spec package documentation generated with [pdoc](https://pdoc.dev/).



  Simplified descriptions are available as [JSON Schema](https://json-schema.org/) (generated with Pydantic):

  | bioimageio.spec version | JSON Schema | documentation[^1] |
  | --- | --- | --- |
  | latest | [bioimageio_schema_latest.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_latest.json) | [latest documentation](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_latest/index.html) |
  | 0.5 | [bioimageio_schema_v0-5.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_v0-5.json) | [0.5 documentation](https://bioimage-io.github.io/spec-bioimage-io/bioimageio_schema_v0-5/index.html) |

  Note: [bioimageio_schema_v0-5.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_v0-5.json) and  [bioimageio_schema_latest.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_latest.json) are identical, but  [bioimageio_schema_latest.json](https://github.com/bioimage-io/spec-bioimage-io/blob/gh-pages/bioimageio_schema_latest.json) will eventually refer to the future `bioimageio_schema_v0-6.json`.



  A flattened view of the types used by the spec that also shows values constraints.

  [rendered](https://bioimage-io.github.io/spec-bioimage-io/interactive_docs_v0-5.html)

  You can also generate these docs locally by running `PYTHONPATH=./scripts python -m interactive_docs`



  We provide some [examples for using rdf.yaml files to describe models, applications, notebooks and datasets](https://github.com/bioimage-io/spec-bioimage-io/blob/main/example_descriptions/examples.md),
  and an [example notebook to programmatically access the models, applications, notebooks and datasets descriptions](https://github.com/bioimage-io/spec-bioimage-io/blob/main/example/load_model_and_create_your_own.ipynb).



  * Due to the limitations of storage services such as Zenodo, which does not support subfolders, it is recommended to place other files in the same directory level of the `rdf.yaml` file and try to avoid using subdirectories.
  * Use the [bioimageio.core Python package](https://github.com/bioimage-io/core-bioimage-io-python) to validate your `rdf.yaml` file.
  * bioimageio.spec keeps evolving. Try to use and upgrade to the most current format version!



  The bioimageio CLI has moved entirely to [bioimageio.core](https://github.com/bioimage-io/core-bioimage-io-python).



  bioimageio.spec can be installed with either `conda` or `pip`.
  We recommend installing `bioimageio.core` instead to get access to the Python programmatic features available in the BioImage.IO community:

  ```console
  conda install -c conda-forge bioimageio.core
  ```

  or

  ```console
  pip install -U bioimageio.core
  ```

  Still, for a lighter package or just testing, you can install the `bioimageio.spec` package solely:

  ```console
  conda install -c conda-forge bioimageio.spec
  ```

  or

  ```console
  pip install -U bioimageio.spec
  ```



  TODO: link to settings in dev docs





  <a href="https://github.com/bioimage-io/spec-bioimage-io/graphs/contributors">
    <img alt="bioimageio.spec contributors" src="https://contrib.rocks/image?repo=bioimage-io/spec-bioimage-io" />
  </a>

  Made with [contrib.rocks](https://contrib.rocks).



  To keep the bioimageio.spec Python package version in sync with the (model) description format version, bioimageio.spec is versioned as MAJOR.MINRO.PATCH.LIB, where MAJOR.MINRO.PATCH correspond to the latest model description format version implemented and LIB may be bumpbed for library changes that do not affect the format version.
  [This change was introduced with bioimageio.spec 0.5.3.1](#bioimageiospec-0531).







  * fix URL validation (checking with actual http requests was erroneously skipped)



  * fix loading tifffile in python 3.8 (pin tifffile)
  * use default tensorflow environments for Keras H5 weights



  * support loading and saving from/to zipfile.ZipFile objects
  * fix bug when packaging with weights priority order (#638)
  * add conda_env module providing helper to create recommended conda environments for model descriptions
  * fix summary formatting
  * improve logged origin for logged messages
  * make the `model.v0_5.ModelDescr.training_data` field a `left_to_right` Union to avoid warnings
  * the deprecated `version_number` is no longer appended to the `id`, but instead set as `version` if no `version` is specified.



  * expose `progressbar` to customize display of download progress
  * expose `get_resource_package_content`
  * prefer `rdf.yaml` over `bioimageio.yaml` (name `bioimageio.yaml` file `rdf.yaml` file when packaging, look for `rdf.yaml` first, etc.)
  * enforce: (generic 0.3/model 0.5 spec) documentation source file encoding has to be UTF-8.
  * bugfix: allow optional pre- and postprocessing to be missing in an RDF (before it required an empty dict).



  * bugfix "reset known files if root changes" (#619)



  note: the versioning scheme was changed as our previous `post` releases include changes beyond what a post release should entail (only changing docstrings, etc).
  This was motivated by the desire to keep the library version in sync with the (model) format version to avoid confusion.
  To keep this relation, but avoid overbearing post releases a library version number is now added as the 4th part MAJOR.MINOR.PATCH.LIB_VERSION.

  * add `load_model_description` and `load_dataset_description`
  * add `ensure_description_is_model` and `ensure_description_is_dataset`
  * expose `perform_io_checks` and `known_files` from `ValidationContext` to `load_description` and `load_description_and_validate_format_only`



  * fix pinning of pydantic



  * update resolving of bioimage.io resource IDs



  * fix SHA-256 value when resolving a RDF version from the bioimage.io collection that is not the latest



  * bump patch version during loading for model 0.5.x
  * improve validation error formatting
  * validate URLs first with a head request, if forbidden, follow up with a get request that is streamed and if that is also forbidden a regular get request.
  * `RelativePath.absolute()` is now a method (not a property) analog to `pathlib.Path`



  * remove collection description
  * update SPDX license list
  * update generic description to 0.3.1
  * update model description to 0.5.3
  * add timeout argument to all requests.get calls



  * added more information to validation summary
  * deprioritize `Path` objects in the `FileSource` union



  * resolve backup DOIs
  * fix resolving relative file paths given as strings
  * allow to bypass download and hashing of known files



  * avoid full download when validating urls



  * resolve version (un)specific collection IDs, e.g. `load_description('affable-shark')`, `load_description('affable-shark/1')`



  * fix model packaging with weights format priority



  * new patch version model 0.5.2



  * new patch version model 0.5.1



  * don't fail if CI env var is a string



  * fix `_internal.io_utils.identify_bioimageio_yaml_file()`



  * new description formats: [generic 0.3, application 0.3, collection 0.3, dataset 0.3, notebook 0.3](generic-030--application-030--collection-030--dataset-030--notebook-030) and [model 0.5](model-050).
  * various API changes, most important functions:
    * `bioimageio.spec.load_description` (replaces `load_raw_resource_description`, interface changed)
    * `bioimageio.spec.validate_format` (new)
    * `bioimageio.spec.dump_description` (replaces `serialize_raw_resource_description_to_dict`, interface changed)
    * `bioimageio.spec.update_format` (interface changed)
  * switch from Marshmallow to Pydantic
    * extended validation
    * one joint, more precise JSON Schema



  * small bugixes
  * better type hints
  * improved tests



  * add `axes` and `eps` to `scale_mean_var`



  * add simple forward compatibility by treating future format versions as latest known (for the respective resource type)



  * Make CLI output more readable

  * find redirected URLs when checking for URL availability



  * Improve error message for non-existing RDF file path given as string

  * Improve documentation for model description's `documentation` field



  * fix enrich_partial_rdf_with_imjoy_plugin (see <https://github.com/bioimage-io/spec-bioimage-io/pull/452>)



  * fix rdf_update of entries in `resolve_collection_entries()`



  * pass root to `enrich_partial_rdf` arg of `resolve_collection_entries()`



  * keep `ResourceDescrption.root_path` as URI for remote resources. This fixes the collection description as the collection entries are resolved after the collection description has been loaded.



  * new bioimageio.spec.partner module adding validate-partner-collection command if optional 'lxml' dependency is available



  * new env var `BIOIMAGEIO_CACHE_WARNINGS_LIMIT` (default: 3) to avoid spam from cache hit warnings

  * more robust conversion of ImportableSourceFile for absolute paths to relative paths (don't fail on non-path source file)



  * resolve symlinks when transforming absolute to relative paths during serialization; see [#438](https://github.com/bioimage-io/spec-bioimage-io/pull/438)



  * fix loading of collection description with id (id used to be ignored)



  * support loading bioimageio resources by their animal nickname (currently only models have nicknames).



  * any field previously expecting a local relative path is now also accepting an absolute path

  * load_raw_resource_description returns a raw resource description which has no relative paths (any relative paths are converted to absolute paths).



  * add command `commands.update_rdf()`/`update-rdf`(cli)



  * fix unresolved ImportableSourceFile



  * fix collection description conversion for type field



  * fix to shape validation for model description 0.4: output shape now needs to be bigger than halo

  * moved objects from bioimageio.spec.shared.utils to bioimageio.spec.shared\[.node_transformer\]
  * additional keys to validation summary: bioimageio_spec_version, status



  * fixes to generic description:
    * ignore value of field `root_path` if present in yaml. This field is used internally and always present in RDF nodes.



  * fixes to collection description:
    * RDFs specified directly in collection description are validated correctly even if their source field does not point to an RDF.
    * nesting of collection description allowed



  * fixed missing field `icon` in generic description's raw node

  * fixes to collection description:
    * RDFs specified directly in collection description are validated correctly
    * no nesting of collection description allowed for now
    * `links` is no longer an explicit collection entry field ("moved" to unknown)



  * new model spec 0.3.5 and 0.4.1



  * `load_raw_resource_description` no longer accepts `update_to_current_format` kwarg (use `update_to_format` instead)



  * `load_raw_resource_description` accepts `update_to_format` kwarg





  * Non-breaking changes
    * remove `version_number` in favor of using `version`



  * Non-breaking changes
    * added `concatenable` flag to index, time and space input axes



  * Non-breaking changes
    * added `DataDependentSize` for `outputs.i.size` to specify an output shape that is not known before inference is run.
    * added optional `inputs.i.optional` field to indicate that a tensor may be `None`
    * made data type assumptions in `preprocessing` and `postprocessing` explicit by adding `'ensure_dtype'` operations per default.
    * allow to specify multiple thresholds (along an `axis`) in a 'binarize' processing step



  * Breaking canges that are fully auto-convertible
    * dropped `download_url`
    * dropped non-file attachments
    * `attachments.files` moved to `attachments.i.source`
  * Non-breaking changes
    * added optional `parent` field



  all generic 0.3.0 changes (except models already have the `parent` field) plus:

  * Breaking changes that are partially auto-convertible
    * `inputs.i.axes` are now defined in more detail (same for `outputs.i.axes`)
    * `inputs.i.shape` moved per axes to `inputs.i.axes.size` (same for `outputs.i.shape`)
    * new pre-/postprocessing 'fixed_zero_mean_unit_variance' separated from 'zero_mean_unit_variance', where `mode=fixed` is no longer valid.
      (for scalar values this is auto-convertible.)
  * Breaking changes that are fully auto-convertible
    * changes in `weights.pytorch_state_dict.architecture`
      * renamed `weights.pytorch_state_dict.architecture.source_file` to `...architecture.source`
    * changes in `weights.pytorch_state_dict.dependencies`
      * only conda environment allowed and specified by `weights.pytorch_state_dict.dependencies.source`
      * new optional field `weights.pytorch_state_dict.dependencies.sha256`
    * changes in `weights.tensorflow_model_bundle.dependencies`
      * same as changes in `weights.pytorch_state_dict.dependencies`
    * moved `test_inputs` to `inputs.i.test_tensor`
    * moved `test_outputs` to `outputs.i.test_tensor`
    * moved `sample_inputs` to `inputs.i.sample_tensor`
    * moved `sample_outputs` to `outputs.i.sample_tensor`
    * renamed `inputs.i.name` to `inputs.i.id`
    * renamed `outputs.i.name` to `outputs.i.id`
    * renamed `inputs.i.preprocessing.name` to `inputs.i.preprocessing.id`
    * renamed `outputs.i.postprocessing.name` to `outputs.i.postprocessing.id`
  * Non-breaking changes:
    * new pre-/postprocessing: `id`='ensure_dtype' with kwarg `dtype`



  * Breaking changes that are fully auto-convertible
    * `id` overwritten with value from `config.bioimageio.nickname` if available
  * Non-breaking changes
    * `version_number` is a new, optional field indicating that an RDF is the nth published version with a given `id`
    * `id_emoji` is a new, optional field (set from `config.bioimageio.nickname_icon` if available)
    * `uploader` is a new, optional field with `email` and an optional `name` subfields



  * Non-breaking changes
    * make pre-/postprocessing kwargs `mode` and `axes` always optional for model description 0.3 and 0.4



  * Non-breaking changes
    * `cite` field is now optional



  * Breaking changes that are fully auto-convertible
    * name field may not include '/' or '\' (conversion removes these)



  * Non-breaking changes
    * Implicit output shape can be expanded by inserting `null` into `shape:scale` and indicating length of new dimension D in the `offset` field. Keep in mind that `D=2*'offset'`.



  * Breaking changes that are fully auto-convertible
    * `parent` field changed to hold a string that is a bioimage.io ID, a URL or a local relative path (and not subfields `uri` and `sha256`)



  * Non-breaking changes
    * new optional field `training_data`



  * Non-breaking changes
    * explicitly define and document dataset description (for now, clone of generic description with type="dataset")



  * Non-breaking changes
    * add optional field `download_url`
    * add optional field `dependencies` to all weight formats (not only pytorch_state_dict)
    * add optional `pytorch_version` to the pytorch_state_dict and torchscript weight formats



  * Bug fixes:
    * in a `pytorch_state_dict` weight entry `architecture` is no longer optional.



  * Non-breaking changes
    * make `authors`, `cite`, `documentation` and `tags` optional

  * Breaking changes that are fully auto-convertible
    * Simplifies collection description 0.2.1 by merging resource type fields together to a `collection` field,
      holindg a list of all resources in the specified collection.



  * Non-breaking changes
    * `rdf_source` new optional field
    * `id` new optional field



  * First official release, extends generic description with fields `application`, `model`, `dataset`, `notebook` and (nested)
    `collection`, which hold lists linking to respective resources.



  * Non-breaking changes
    * add optional `email` and `github_user` fields to entries in `authors`
    * add optional `maintainers` field (entries like in `authors` but  `github_user` is required (and `name` is not))



  * Breaking changes that are fully auto-convertible
    * moved field `dependencies` to `weights:pytorch_state_dict:dependencies`

  * Non-breaking changes
    * `documentation` field accepts URLs as well



  * Non-breaking changes
    * `documentation` field accepts URLs as well



  * Breaking changes
    * model inputs and outputs may not use duplicated names.
    * model field `sha256` is required if `pytorch_state_dict` weights are defined.
      and is now moved to the `pytroch_state_dict` entry as `architecture_sha256`.

  * Breaking changes that are fully auto-convertible
    * model fields language and framework are removed.
    * model field `source` is renamed `architecture` and is moved together with `kwargs` to the `pytorch_state_dict`
      weights entry (if it exists, otherwise they are removed).
    * the weight format `pytorch_script` was renamed to `torchscript`.
  * Other changes
    * model inputs (like outputs) may be defined by `scale`ing and `offset`ing a `reference_tensor`
    * a `maintainers` field was added to the model description.
    * the entries in the `authors` field may now additionally contain `email` or `github_user`.
    * the summary returned by the `validate` command now also contains a list of warnings.
    * an `update_format` command was added to aid with updating older RDFs by applying auto-conversion.



  * Non-breaking changes
    * Add optional parameter `eps` to `scale_range` postprocessing.



  * Breaking changes that are fully auto-convertible
    * `reference_input` for implicit output tensor shape was renamed to `reference_tensor`



  * Breaking changes
    * The RDF file name in a package should be `rdf.yaml` for all the RDF (not `model.yaml`);
    * Change `authors` and `packaged_by` fields from List[str] to List[Author] with Author consisting of a dictionary `{name: '<Full name>', affiliation: '<Affiliation>', orcid: 'optional orcid id'}`;
    * Add a mandatory `type` field to comply with the generic description. Only valid value is 'model' for model description;
    * Only allow `license` identifier from the [SPDX license list](https://spdx.org/licenses/);

  * Non-breaking changes
    * Add optional `version` field (default 0.1.0) to keep track of model changes;
    * Allow the values in the `attachments` list to be any values besides URI;


pkgId: feef46351038eba23acf0dc98574a80b35abee91fdfc18b47bd93b637e2b449a
name: python-bioinfokit
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: Bioinformatics data analysis and visualization toolkit
url: https://github.com/reneshbedre/bioinfokit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioinfokit-2.1.4-1.src.rpm
checksum_type: sha256
description:
  `df` |Pandas dataframe table having atleast gene IDs, log fold change, P-values or adjusted P-values columns
  `lfc` | Name of a column having log or absolute fold change values [string][default:logFC]
  `pv` | Name of a column having P-values or adjusted P-values [string][default:p_values]
  `lfc_thr` | Log fold change cutoff for up and downregulated genes [[Tuple](https://www.reneshbedre.com/blog/python-tuples.html) or list][default:(1.0, 1.0)]
  `pv_thr` |  p value or adjusted p value cutoff for up and downregulated genes [[Tuple](https://www.reneshbedre.com/blog/python-tuples.html) or list][default:(0.05, 0.05)]
  `color` | [Tuple](https://www.reneshbedre.com/blog/python-tuples.html) of three colors [[Tuple](https://www.reneshbedre.com/blog/python-tuples.html) or list][default: color=("green", "grey", "red")]
  `valpha` | Transparency of points on volcano plot [float (between 0 and 1)][default: 1.0]
  `geneid` | Name of a column having gene Ids. This is necessary for plotting gene label on the points [string][default: None]
  `genenames` | [Tuple](https://www.reneshbedre.com/blog/python-tuples.html) of gene Ids to label the points. The gene Ids must be present in the geneid column. If this option set to "deg" it will label all genes defined by lfc_thr and pv_thr [string, tuple, dict][default: None]
  `gfont` | Font size for genenames [float][default: 10.0]. gfont not compatible with gstyle=2.
  `dim` | Figure size [[Tuple](https://www.reneshbedre.com/blog/python-tuples.html) of two floats (width, height) in inches][default: (5, 5)]
  `r` | Figure resolution in dpi [int][default: 300]. Not compatible with `show`= True
  `ar` | Rotation of X and Y-axis ticks labels [float][default: 90]
  `dotsize`| The size of the dots in the plot [float][default: 8]
  `markerdot` | Shape of the dot marker. See more options at  https://matplotlib.org/3.1.1/api/markers_api.html [string][default: "o"]
  `sign_line` | Show grid lines on plot with defined log fold change (`lfc_thr`) and P-value (`pv_thr`) threshold value [True or False][default:False]
  `gstyle` | Style of the text for genenames. 1 for default text and 2 for box text [int][default: 1]
  `show`  | Show the figure on console instead of saving in current folder [True or False][default:False]
  `figtype` | Format of figure to save. Supported format are eps, pdf, pgf, png, ps, raw, rgba, svg, svgz [string][default:'png']
  `axtickfontsize` | Font size for axis ticks [float][default: 9]
  `axtickfontname` | Font name for axis ticks [string][default: 'Arial']
  `axlabelfontsize` | Font size for axis labels [float][default: 9]
  `axlabelfontname` | Font name for axis labels [string][default: 'Arial']
  `axxlabel` | Label for X-axis. If you provide this option, default label will be replaced [string][default: None]
  `axylabel` | Label for Y-axis. If you provide this option, default label will be replaced [string][default: None]
  `xlm` | Range of ticks to plot on X-axis [float (left, right, interval)][default: None]
  `ylm` | Range of ticks to plot on Y-axis [float (bottom, top, interval)][default: None]
  `plotlegend` | plot legend on volcano plot  [True or False][default:False]
  `legendpos` | position of the legend on plot. For more options see loc parameter at https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.legend.html  [string ][default:"best"]
  `figname` | name of figure [string ][default:"volcano"]
  `legendanchor` | position of the legend outside of the plot. For more options see bbox_to_anchor parameter at https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.legend.html  [list][default:None]
  `legendlabels` | legend label names. If you provide custom label names keep the same order of label names as default [list][default:['significant up', 'not significant', 'significant down']]
  `theme` | Change background theme. If theme set to `dark`, the dark background will be produced instead of white [string][default:'None']
  Returns:
  Volcano plot image in same directory (volcano.png)
  <a href="https://reneshbedre.com/blog/volcano.html" target="_blank">Working example</a>

  latest update v2.0.8
  `bioinfokit.visuz.GeneExpression.involcano(table, lfc, pv, lfc_thr, pv_thr, color, valpha, geneid, genenames, gfont, gstyle,
      dotsize, markerdot, r, dim, show, figtype, axxlabel, axylabel, axlabelfontsize, axtickfontsize,
      axtickfontname, plotlegend, legendpos, legendanchor, figname, legendlabels, ar, theme)`


pkgId: 497a59e482c8f2eae0108f82b7fddd24f3426720da64c3ce5a11f5ef51acb664
name: python-bioio
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Image reading, metadata management, and image writing for Microscopy images in Python
url: https://github.com/bioio-devs/bioio
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioio-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [See the full documentation on our GitHub pages site](https://bioio-devs.github.io/bioio/OVERVIEW.html)

  Install bioio alongside OME TIFF and OME ZARR plug-ins with pip (this example won't use the OME ZARR plug-in):
  `pip install bioio bioio-ome-tiff bioio-ome-zarr`
  ```python
  from bioio import BioImage

  img = BioImage("my_file.tiff")  # selects the first scene found
  img.data  # returns 5D TCZYX numpy array
  img.xarray_data  # returns 5D TCZYX xarray data array backed by numpy
  img.dims  # returns a Dimensions object
  img.dims.order  # returns string "TCZYX"
  img.dims.X  # returns size of X dimension
  img.shape  # returns tuple of dimension sizes in TCZYX order
  img.get_image_data("CZYX", T=0)  # returns 4D CZYX numpy array

  img.current_scene

  img.scenes

  img.set_scene("Image:1")

  img.set_scene(1)


  ```

  Bioio handles a variety of different image types through specific plug-ins. The bioio-dev supported plug-ins can be found within
  this registry.
  | Plug-in                | Extension   | Repository          |
  |------------------------|-------------|---------------------|
  | arraylike              | [ArrayLike](https://github.com/bioio-devs/bioio-base/blob/9ff0a17a20d09b1b11639d149b1e71801c9d68d8/bioio_base/types.py#L15)  | Built-In           |
  | bioio-czi              | .czi        | [Repo](https://github.com/bioio-devs/bioio-czi)           |
  | bioio-dv               | .dv, .r3d   | [Repo](https://github.com/bioio-devs/bioio-dv)           |
  | bioio-imageio          | .jpg, .png, [Full List](https://github.com/bioio-devs/bioio-imageio/blob/6829370644b9780cfde35fa9d2cd5cea9f743681/bioio_imageio/reader_metadata.py#L26)  | [Repo](https://github.com/bioio-devs/bioio-imageio)           |
  | bioio-lif              | .lif        | [Repo](https://github.com/bioio-devs/bioio-lif)           |
  | bioio-nd2              | .nd2        | [Repo](https://github.com/bioio-devs/bioio-nd2)           |
  | bioio-ome-tiff         | .ome.tiff, .tiff  | [Repo](https://github.com/bioio-devs/bioio-ome-tiff)           |
  | bioio-ome-tiled-tiff   | .tiles.ome.tif   | [Repo](https://github.com/bioio-devs/bioio-ome-tiled-tiff)           |
  | bioio-ome-zarr         | .zarr       | [Repo](https://github.com/bioio-devs/bioio-ome-zarr)           |
  | bioio-sldy             | .sldy, .dir | [Repo](https://github.com/bioio-devs/bioio-sldy)           |
  | bioio-tifffile         | .tif , .tiff| [Repo](https://github.com/bioio-devs/bioio-tifffile)           |
  | bioio-tiff-glob        | .tiff (glob)| [Repo](https://github.com/bioio-devs/bioio-tiff-glob)           |
  | bioio-bioformats       | [Full List](https://github.com/bioio-devs/bioio-bioformats/blob/175399d10d64194adcc7a6048c7b7537591824de/bioio_bioformats/reader_metadata.py#L24) | [Repo](https://github.com/bioio-devs/bioio-bioformats)           |
  Each reader plugin should closely follow the specification laid out in `bioio-base`. As such, it is likely common that reader plugins won't distribute their own documentation and users should instead review  [`bioio_base.reader.Reader`](https://bioio-devs.github.io/bioio-base/bioio_base.html#bioio_base.reader.Reader) for API documentation for the underlying Reader API. We encourage plugin authors to publish their own documentation if they change or include new features into their published image readers.

  [_Click here to view all open issues in bioio-devs organization at once_](https://github.com/search?q=user%3Abioio-devs+is%3Aissue+is%3Aopen&type=issues&ref=advsearch)


pkgId: 9ef0103cb6236b70513555a7b8a0bb5173874db2f0787f79682b4a60d096e7dc
name: python-bioio-bioformats
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A BioIO reader for reading bioformats formatted images.
url: https://github.com/bioio-devs/bioio-bioformats
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioio-bioformats-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [See the full documentation on our GitHub pages site](https://bioio-devs.github.io/bioio/OVERVIEW.html) - the generic use and installation instructions there will work for this package.
  Information about the base reader this package relies on can be found in the `bioio-base` repository [here](https://github.com/bioio-devs/bioio-base)

  **Stable Release:** `pip install bioio-bioformats`<br>
  **Development Head:** `pip install git+https://github.com/bioio-devs/bioio-bioformats.git`

  **This package utilizes bioformats which depends on java**
  To install java and maven with conda, run:
  `conda install -c conda-forge scyjava`
  You may need to deactivate/reactivate your environment after installing. If you are *still* getting a `JVMNotFoundException`, try setting `JAVA_HOME` as follows:

  `export JAVA_HOME=$CONDA_PREFIX`

  `set JAVA_HOME=%CONDA_PREFIX%\\Library`

  Install bioio-bioformats alongside bioio:
  `pip install bioio bioio-bioformats`
  This example shows a simple use case for just accessing the pixel data of the image
  by explicitly passing this `Reader` into the `BioImage`. Passing the `Reader` into
  the `BioImage` instance is optional as `bioio` will automatically detect installed
  plug-ins and auto-select the most recently installed plug-in that supports the file
  passed in.
  ```python
  from bioio import BioImage
  import bioio_bioformats
  img = BioImage("my_file.tiff", reader=bioio_bioformats.Reader)
  img.data
  ```

  [_Click here to view all open issues in bioio-devs organization at once_](https://github.com/search?q=user%3Abioio-devs+is%3Aissue+is%3Aopen&type=issues&ref=advsearch) or check this repository's issue tab.

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.


pkgId: 7382ea4f7568a2a3f362d0e4b5c4fe1d2edbe8de331f23245a8e3c1d23c19f47
name: python-bioio-czi
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A Bioio reader plugin for reading czi images.
url: https://github.com/bioio-devs/bioio-czi
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioio-czi-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [See the full documentation on our GitHub pages site](https://bioio-devs.github.io/bioio/OVERVIEW.html) - the generic use and installation instructions there will work for this package.
  Information about the base reader this package relies on can be found in the `bioio-base` repository [here](https://github.com/bioio-devs/bioio-base)

  **Stable Release:** `pip install bioio-czi`<br>
  **Development Head:** `pip install git+https://github.com/bioio-devs/bioio-czi.git`

  Install bioio-czi alongside bioio:
  `pip install bioio bioio-czi`
  This example shows a simple use case for just accessing the pixel data of the image
  by explicitly passing this `Reader` into the `BioImage`. Passing the `Reader` into
  the `BioImage` instance is optional as `bioio` will automatically detect installed
  plug-ins and auto-select the most recently installed plug-in that supports the file
  passed in.
  ```python
  from bioio import BioImage
  import bioio_czi
  img = BioImage("my_file.czi", reader=bioio_czi.Reader)
  img.data
  ```

  [_Click here to view all open issues in bioio-devs organization at once_](https://github.com/search?q=user%3Abioio-devs+is%3Aissue+is%3Aopen&type=issues&ref=advsearch) or check this repository's issue tab.

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.


pkgId: fdd2c0a6a14186cb320fb8e60b5d06a45b929560967d57979756bb0bcac3c6c0
name: python-bioio-imageio
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A BioIO reader plugin for reading simple image formats using imageio.
url: https://github.com/bioio-devs/bioio-imageio
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioio-imageio-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [See the full documentation on our GitHub pages site](https://bioio-devs.github.io/bioio/OVERVIEW.html) - the generic use and installation instructions there will work for this package.
  Information about the base reader this package relies on can be found in the `bioio-base` repository [here](https://github.com/bioio-devs/bioio-base)

  **Stable Release:** `pip install bioio-imageio`<br>
  **Development Head:** `pip install git+https://github.com/bioio-devs/bioio-imageio.git`

  Install bioio-imageio alongside bioio:
  `pip install bioio bioio-imageio`
  This example shows a simple use case for just accessing the pixel data of the image
  by explicitly passing this `Reader` into the `BioImage`. Passing the `Reader` into
  the `BioImage` instance is optional as `bioio` will automatically detect installed
  plug-ins and auto-select the most recently installed plug-in that supports the file
  passed in.
  ```python
  from bioio import BioImage
  import bioio_imageio
  img = BioImage("my_file.mp4", reader=bioio_imageio.Reader)
  img.data
  ```

  [_Click here to view all open issues in bioio-devs organization at once_](https://github.com/search?q=user%3Abioio-devs+is%3Aissue+is%3Aopen&type=issues&ref=advsearch) or check this repository's issue tab.

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.


pkgId: 41f3284557dbd8ce3df7490e8b85ab277213ebb2038605e11389cd3a62d6c238
name: python-bioio-ome-tiff
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A BioIO reader plugin for reading tiff files in the OME format.
url: https://github.com/bioio-devs/bioio-ome-tiff
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioio-ome-tiff-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [See the full documentation on our GitHub pages site](https://bioio-devs.github.io/bioio/OVERVIEW.html) - the generic use and installation instructions there will work for this package.
  Information about the base reader this package relies on can be found in the `bioio-base` repository [here](https://github.com/bioio-devs/bioio-base)

  **Stable Release:** `pip install bioio-ome-tiff`<br>
  **Development Head:** `pip install git+https://github.com/bioio-devs/bioio-ome-tiff.git`

  Install bioio-ome-tiff alongside bioio:
  `pip install bioio bioio-ome-tiff`
  This example shows a simple use case for just accessing the pixel data of the image
  by explicitly passing this `Reader` into the `BioImage`. Passing the `Reader` into
  the `BioImage` instance is optional as `bioio` will automatically detect installed
  plug-ins and auto-select the most recently installed plug-in that supports the file
  passed in.
  ```python
  from bioio import BioImage
  import bioio_ome_tiff
  img = BioImage("my_file.ome.tiff", reader=bioio_ome_tiff.Reader)
  img.data
  ```

  [_Click here to view all open issues in bioio-devs organization at once_](https://github.com/search?q=user%3Abioio-devs+is%3Aissue+is%3Aopen&type=issues&ref=advsearch) or check this repository's issue tab.

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.


pkgId: be12613757331ad6da9d0ef695d571272b7e3025ae91ae0cf2584856e5aa7eec
name: python-bioio-ome-zarr
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A BioIO reader plugin for reading Zarr files in the OME format.
url: https://github.com/BrianWhitneyAI/bioio-ome-zarr
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioio-ome-zarr-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [See the full documentation on our GitHub pages site](https://bioio-devs.github.io/bioio/OVERVIEW.html) - the generic use and installation instructions there will work for this package.
  Information about the base reader this package relies on can be found in the `bioio-base` repository [here](https://github.com/bioio-devs/bioio-base)

  **Stable Release:** `pip install bioio-ome-zarr`<br>
  **Development Head:** `pip install git+https://github.com/bioio-devs/bioio-ome-zarr.git`

  Install bioio-ome-zarr alongside bioio:
  `pip install bioio bioio-ome-zarr`
  This example shows a simple use case for just accessing the pixel data of the image
  by explicitly passing this `Reader` into the `BioImage`. Passing the `Reader` into
  the `BioImage` instance is optional as `bioio` will automatically detect installed
  plug-ins and auto-select the most recently installed plug-in that supports the file
  passed in.
  ```python
  from bioio import BioImage
  import bioio_ome_zarr
  img = BioImage("my_file.zarr", reader=bioio_ome_zarr.Reader)
  img.data
  ```

  To read from private S3 buckets, [credentials](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) must be configured. Public buckets can be accessed without credentials.
  ```python
  from bioio import BioImage
  path = "https://allencell.s3.amazonaws.com/aics/nuc-morph-dataset/hipsc_fov_nuclei_timelapse_dataset/hipsc_fov_nuclei_timelapse_data_used_for_analysis/baseline_colonies_fov_timelapse_dataset/20200323_09_small/raw.ome.zarr"
  image = BioImage(path)
  print(image.get_image_dask_data())
  ```
  If using an `s3://` path to access a public S3 bucket, the `BioImage` constructor must be given a dictionary with `anon: True` in the `fs_kwargs` argument.
  ```python
  from bioio import BioImage
  path = "s3://allencell/aics/nuc-morph-dataset/hipsc_fov_nuclei_timelapse_dataset/hipsc_fov_nuclei_timelapse_data_used_for_analysis/baseline_colonies_fov_timelapse_dataset/20200323_09_small/raw.ome.zarr"
  image = BioImage(path, fs_kwargs=dict(anon=True))
  print(image.get_image_dask_data())
  ```

  [_Click here to view all open issues in bioio-devs organization at once_](https://github.com/search?q=user%3Abioio-devs+is%3Aissue+is%3Aopen&type=issues&ref=advsearch) or check this repository's issue tab.

  See [CONTRIBUTING.md](CONTRIBUTING.md) for information related to developing the code.


pkgId: 5611d1148ca4cf3d76777a59e8b9706357ecf4b60048508fa2249092047e4030
name: python-biolearn
arch: src
version: 0.6.6
epoch: 0
release: 1
summary: Machine learning for biomarkers computing
url: https://pypi.org/project/biolearn/
rpm_license: new BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biolearn-0.6.6-1.src.rpm
checksum_type: sha256
description:
  Biolearn enables easy and versatile analyses of biomarkers of aging data. It provides tools to easily load data from publicly available sources like the
  `Gene Expression Omnibus <https://www.ncbi.nlm.nih.gov/geo/>`_, `National Health and Nutrition Examimation Survey <https://www.cdc.gov/nchs/nhanes/index.htm>`_,
  and the `Framingham Heart Study <https://www.framinghamheartstudy.org/>`_. Biolearn also contains reference implemenations for common aging clock such at the
  Horvath clock, DunedinPACE and many others that can easily be run in only a few lines of code. You can read more about it in our `paper <https://www.biorxiv.org/content/10.1101/2023.12.02.569722v2>`_.
      This is a prerelease version of the biolearn library. There may be bugs and interfaces are subject to change.


pkgId: 6d13c49790fe76c16efb5f99dc4c592db7fa3b07e8cbe5e31ba57f7f42fa4812
name: python-biolearns
arch: src
version: 0.0.62
epoch: 0
release: 1
summary: BioLearns: Computational Biology and Bioinformatics Toolbox in Python
url: https://pypi.org/project/biolearns/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biolearns-0.0.62-1.src.rpm
checksum_type: sha256
description:
  BioLearns: Computational Biology and Bioinformatics Toolbox in Python http://biolearns.medicine.iu.edu

  <div style="text-align:center"><img src="figures/logo.png" width=300/></div>

  [![license](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/huangzhii/biolearns/blob/master/LICENSE)



  * From PyPI

  ```bash
  pip install biolearns -U
  ```



  * We select three examples listed below. For full list of tutorial, check our github wiki page:

      [Wiki](https://github.com/huangzhii/biolearns/wiki)


  Please note that this is a pre-release version of the BioLearns which is still undergoing final testing before its official release. The website, its software and all content found on it are provided on an "as is" and "as available" basis. BioLearns does not give any warranties, whether express or implied, as to the suitability or usability of the website, its software or any of its content. BioLearns will not be liable for any loss, whether such loss is direct, indirect, special or consequential, suffered by any party as a result of their use of the libraries or content. Any usage of the libraries is done at the user's own risk and the user will be solely responsible for any damage to any computer system or loss of data that results from such activities. Should you encounter any bugs, glitches, lack of functionality or other problems on the website, please let us know immediately so we can rectify these accordingly. Your help in this regard is greatly appreciated.







  Data is downloaded directly from https://gdac.broadinstitute.org/.
  The results here are in whole or part based upon data generated by
  the TCGA Research Network: https://www.cancer.gov/tcga.

  ```python
  from biolearns.dataset import TCGA
  ```

  ```python
  brca = TCGA('BRCA')
  mRNAseq = brca.mRNAseq
  clinical = brca.clinical
  ```



  |              | Barcode            | Cancer full name         | Version            |
  |---|---|---|---|
  | 1      |  ACC          |  Adrenocortical carcinoma     | 2016_01_28 |
  | 2      |  BLCA         |  Bladder urothelial carcinoma         | 2016_01_28 |
  | 3      |  BRCA         |  Breast invasive carcinoma    | 2016_01_28 |
  | 4      |  CESC         |  Cervical and endocervical cancers    | 2016_01_28 |
  | 5      |  CHOL         |  Cholangiocarcinoma   | 2016_01_28 |
  | 6      |  COAD         |  Colon adenocarcinoma         | 2016_01_28 |
  | 7      |  COADREAD     |  Colorectal adenocarcinoma    | 2016_01_28 |
  | 8      |  DLBC         |  Lymphoid Neoplasm Diffuse Large B-cell Lymphoma      | 2016_01_28 |
  | 9      |  ESCA         |  Esophageal carcinoma         | 2016_01_28 |
  | ...     |  ...         |  ...          | ... |




  We firstly download and access the mRNAseq data.
  ```python
  from biolearns.dataset import TCGA

  brca = TCGA('BRCA')
  mRNAseq = brca.mRNAseq
  ```

  mRNAseq data is noisy. We filter out 50% of genes with lowest mean values, and then filter out 50% remained genes with lowest variance values.

  ```python
  from biolearns.preprocessing import expression_filter
  mRNAseq = expression_filter(mRNAseq, meanq = 0.5, varq = 0.5)
  ```

  We then use lmQCM class to create an lmQCM object ```lobj```.

  The gene co-expression analysis is performed by simply call the ```fit()``` function.

  ```python
  from biolearns.coexpression import lmQCM

  lobj = lmQCM(mRNAseq)
  clusters, genes, eigengene_mat = lobj.fit()
  ```



  We firstly download and access the mRNAseq data. Use breast cancer as an example.
  ```python
  from biolearns.dataset import TCGA

  brca = TCGA('BRCA')
  mRNAseq = brca.mRNAseq
  ```

  We import logranktest from survival subpackage. Choose gene "ABLIM3" as the univariate input.
  ```python
  from biolearns.survival import logranktest

  r = mRNAseq.loc['ABLIM3',].values
  ```

  We find the intersection of univariate, time, and event data
  ```python
  bcd_m = [b[:12] for b in mRNAseq.columns]
  bcd_p = [b[:12] for b in clinical.index]
  bcd = np.intersect1d(bcd_m, bcd_p)

  r = r[np.nonzero(np.in1d(bcd, bcd_m))[0]]
  t = brca.overall_survival_time[np.nonzero(np.in1d(bcd, bcd_p))[0]]
  e = brca.overall_survival_event[np.nonzero(np.in1d(bcd, bcd_p))[0]]
  ```

  We perform log-rank test:

  ```python
  logrank_results, fig = logranktest(r[~np.isnan(t)], t[~np.isnan(t)], e[~np.isnan(t)])
  test_statistic, p_value = logrank_results.test_statistic, logrank_results.p_value
  ```

  The output figure looks like:

  <div style="text-align:center"><img src="https://github.com/huangzhii/biolearns/blob/master/figures/survival_plot_BRCA_ABLIM3.png" width=600/></div>


pkgId: 1fa3a416717f7bb35c2e27a949439c32e31b6c1824ede8ee508fa45fa527fc0c
name: python-biolink-model
arch: src
version: 4.2.4
epoch: 0
release: 1
url: https://pypi.org/project/biolink-model/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biolink-model-4.2.4-1.src.rpm
checksum_type: sha256
summary:
  The Biolink Model is a high-level data model designed to standardize types and relationships in biological knowledgebases.

description:
  [![Biolink Model](https://img.shields.io/github/v/release/biolink/biolink-model?style=flat-square)](https://img.shields.io/github/v/release/biolink/biolink-model?style=flat-square)
  [![Python 3.9](https://img.shields.io/badge/python-3.9+-blue)](https://img.shields.io/badge/python-3.9+-blue)
  [![DOI](https://zenodo.org/badge/112995625.svg)](https://zenodo.org/badge/latestdoi/112995625)


  <img src="src/docs/images/biolink-logo.png" width="20%">



  **Biolink Model:** https://w3id.org/biolink/biolink-model.yaml

  Quickstart docs:

  For a good overview of the biolink-model, [watch Chris Mungall's talk](https://www.youtube.com/watch?v=RE1hFm8lvJA&t=2s) at ICBO 2020.

  - Browse the model: [https://biolink.github.io/biolink-model](https://biolink.github.io/biolink-model)
    - [named thing](https://biolink.github.io/biolink-model/NamedThing/)
    - [association](https://biolink.github.io/biolink-model/Association/)
    - [predicate](https://biolink.github.io/biolink-model/related_to/)


  Refer to the following resources for a quick introduction to the Biolink Model:
  - [Introduction to the Biolink Datamodel](https://www.slideshare.net/cmungall/introduction-to-the-biolink-datamodel)
  - [Biolink Model - A community driven data model for life sciences](https://bit.ly/biolink-model-workshop-biocuration-2020) (Biocuration 2020)
      - Slides: https://bit.ly/biolink-model-workshop-biocuration-2020
      - Video: https://www.youtube.com/watch?v=RE1hFm8lvJA

  See also the Biolink Model Documentation for help in [understanding](https://biolink.github.io/biolink-model/), [curating](https://biolink.github.io/biolink-model/curating-the-model/), and [working](https://biolink.github.io/biolink-model/working-with-the-model/) with the model.




  The purpose of the Biolink Model is to provide a high-level datamodel of
  biological entities (genes, diseases, phenotypes, pathways, individuals, substances, etc),
  their properties, relationships, and enumerate ways in which they can be associated.

  The representation is independent of storage technology or metamodel (Solr documents, neo4j/property graphs,
  RDF/OWL, JSON, CSVs, etc). Different mappings to each of these are provided.

  The specification of the Biolink Model is a [single YAML file](biolink-model.yaml) built using [linkml](https://github.com/linkml).
  The basic elements of the YAML are:

   - Class Definitions: definitions of upper level *classes* representing both 'named thing' and 'association'
   - Slot Definitions: definitions of *slots* (aka properties) that can be used to relate members of these classes to other classes or data types. Slots collectively refer to predicates, node properties, and edge properties

  The model itself is being used in the following projects:
  - [NCATS Biomedical Data Translator](https://ncats.nih.gov/translator)
  - [Monarch Initiative](https://monarchinitiative.org/)
  - [KG-COVID-19](https://github.com/Knowledge-Graph-Hub/kg-covid-19/wiki)
  - [KG Microbe](https://github.com/Knowledge-Graph-Hub/kg-microbe)
  - [Illuminating the Druggable Genome](https://github.com/Knowledge-Graph-Hub/kg-idg)




  The main source of truth is [biolink-model.yaml](biolink-model.yaml). This is a YAML file that is intended to
  be relatively simple to view and edit in its native form.

  The yaml definition is currently used to derive:

    - [JSON Schema](https://github.com/biolink/biolink-model/blob/master/project/jsonschema/biolink_model.schema.json)
    - [Python dataclasses](https://github.com/biolink/biolink-model/blob/master/src/biolink_model/datamodel/model.py)
    - [ProtoBuf definitions](https://github.com/biolink/biolink-model/blob/master/project/protobuf/biolink_model.proto)
    - [GraphQL](https://github.com/biolink/biolink-model/blob/master/project/graphql/biolink_model.graphql)
    - [OWL](https://github.com/biolink/biolink-model/blob/master/project/owl/biolink_model.owl.ttl)
    - [RDF Shape Expressions](https://github.com/biolink/biolink-model/blob/master/project/shex/biolink_model.shex)
    - [JSON-LD context](https://github.com/biolink/biolink-model/blob/master/project/jsonld/biolink_model.context.jsonld)
    - [SHACL Shapes](https://github.com/biolink/biolink-model/blob/master/project/shacl/biolink_model.shacl.ttl)
    - [ShEx Shapes](https://github.com/biolink/biolink-model/blob/master/project/shex/biolink_model.shex)



  Unni DR, Moxon SAT, Bada M, Brush M, Bruskiewich R, Caufield JH, Clemons PA, Dancik V, Dumontier M, Fecho K, Glusman G, Hadlock JJ, Harris NL, Joshi A, Putman T, Qin G, Ramsey SA, Shefchek KA, Solbrig H, Soman K, Thessen AE, Haendel MA, Bizon C, Mungall CJ, The Biomedical Data Translator Consortium (2022).
  Biolink Model: A universal schema for knowledge graphs in clinical, biomedical, and translational science. Clin Transl Sci. Wiley; 2022 Jun 6; https://onlinelibrary.wiley.com/doi/10.1111/cts.13302


pkgId: 4cb92da88aeb948918c0c3b73b61da33d7c84fbf98021ff4c982d76c20494171
name: python-bioluigi
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Reusable and maintained Luigi tasks to incorporate in bioinformatics pipelines
url: https://github.com/pavlidisLab/bioluigi
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioluigi-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/PavlidisLab/bioluigi/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/PavlidisLab/bioluigi/actions/workflows/ci.yml)
  [![Documentation Status](https://readthedocs.org/projects/bioluigi/badge/?version=latest)](https://bioluigi.readthedocs.io/en/latest/?badge=latest)

  Reusable and maintained Luigi tasks to incorporate in bioinformatics pipelines



  Provides Luigi tasks for tools from [samtools](http://www.htslib.org/doc/samtools.html), [bcftools](http://www.htslib.org/doc/bcftools.html), [STAR](https://github.com/alexdobin/STAR), [RSEM](http://deweylab.github.io/RSEM/), [vcfanno](http://brentp.github.io/vcfanno/), [GATK](https://software.broadinstitute.org/gatk/), [Ensembl VEP](https://www.ensembl.org/vep) and much more!

  Reuses as much as possible the `ExternalProgramTask` interface from the [external_program contrib module](https://luigi.readthedocs.io/en/stable/api/luigi.contrib.external_program.html)
  and extends its feature to make it work on modern scheduler such as [Slurm](https://slurm.schedmd.com/).

  Provides basic resource management for a local scheduler: all tasks are annotated with reasonable default `cpus` and `memory` parameters that can be tuned and constrained via the `[resources]` configuration. In the case of externally scheduled tasks, the resource management is deferred.

  Provides a command-line interface for interacting more conveniently with Luigi scheduler.

  ```bash
  bioluigi list [--status STATUS] [--user USER] [--detailed] TASK_GLOB
  bioluigi show TASK_ID
  ```



  Here's a list of supported tools:

   - [sratoolkit](https://ncbi.github.io/sra-tools/) with `prefetch` and `fastq-dump`
   - [bcftools](http://www.htslib.org/doc/bcftools.html)
   - [FastQC](https://www.bioinformatics.babraham.ac.uk/projects/fastqc/)
   - [MultiQC](https://multiqc.info/)



   - local
   - [Slurm](https://slurm.schedmd.com/)



  The most convenient way of using the pre-defined tasks is to yield them dynamically in the body of the `run` function. It's also possible to require them since they inherit from `luigi.Task`.

  ```python
  import luigi
  from bioluigi.tasks import bcftools

  def MyTask(luigi.Task)
      def input(self):
          return luigi.LocalTarget('source.vcf.gz')

      def run(self):
          yield bcftools.Annotate(self.input().path,
                                  annotations_file,
                                  self.output().path,
                                  ...,
                                  scheduler='slurm',
                                  cpus=8)

      def output(self):
          return luigi.LocalTarget('annotated.vcf.gz')
  ```

  You can define your own scheduled task by implementing the `ScheduledExternalProgramTask` class. Note that the default scheduler is `local` and will use Luigi's `[resources]` allocation mechanism.

  ```python
  import datetime
  from bioluigi.scheduled_external_program import ScheduledExternalProgramTask

  class MyScheduledTask(ScheduledExternalProgramTask):
      scheduler = 'slurm'
      walltime = datetime.timedelta(seconds=10)
      cpus = 1
      memory = 1

      def program_args(self):
          return ['sleep', '10']
  ```


pkgId: e520e61f871703060f242a91029b0efc61e16d8e6e0caa47bd6221d3b11a3b4c
name: python-biomage-programmatic-interface
arch: src
version: 0.0.39
epoch: 0
release: 1
summary: For programmatic upload of files to Cellencis
url: https://github.com/biomage-org/programmatic_interface
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomage-programmatic-interface-0.0.39-1.src.rpm
checksum_type: sha256
description:
  \n# biomage-programmatic-interface



  This python package provides an easy way to create projects and upload samples into Biomage.


  To install the package execute the following line:

  `pip install biomage-programmatic-interface`


  In order to use the package you first need to create an account in Biomage (https://scp.biomage.net/) if you don't have one yet.

  Then the package is used in the following way:

  ```python
  import biomage_programmatic_interface as bpi



  connection = bpi.Connection('email', 'password', 'instance_url')


  experiment = connection.create_experiment('experiment name')


  experiment.upload_samples('local/path/to/samples')
  ```

  Once the upload is complete you can navigate to [Biomage](https://scp.biomage.net/) and process your project there.



  The object accepts 3 parameters:
  1. `email` - Biomage email
  2. `password` - Biomage password
  3. `instance_url` - Biomage instance url

  - Copy the url of the Biomage instance *excluding* `https://`
  - If the url is https://scp.biomage.net/ enter just the domain name: `scp.biomage.net`





  If you cloned the repository and want to try using your local version, do the following:

  - Install the local version of the pip package:
  ```bash
  cd programmatic_interface
  make install
  ```

  - Now you can import the package and use your local version

  ```python
  import biomage_programmatic_interface as bpi
  ```

  ***NOTE***: There is **NO** need to run `make install` every time you make changes to the package. When the local changes have been saved the changes will be automatically reflected.



  When creating the `connection` object set the `instance_url` to `local`. Now the programmatic interface will use your local api (https://localhost:3000)

  ```python
  import biomage_programmatic_interface as bpi
  conn = bpi.Connection(<YOUR EMAIL>, <YOUR PASSWORD>, 'local')
  ...
  ```


  Set the full path of the instance url (e.g. `https://api-{ENVIRONMENT NAME}.scp-staging.biomage.net/`)

  ```python
  import biomage_programmatic_interface as bpi
  conn = bpi.Connection(<YOUR EMAIL>, <YOUR PASSWORD>, 'https://api-{ENVIRONMENT NAME}.scp-staging.biomage.net/')
  ...
  ```

  *NOTE: the url is that of the api (i.e. `api-`) and not that of the ui*


pkgId: ade9356e1902f3f8d2dcc66cff9eacb3434a42ed35eebb905b2d7501c17b5803
name: python-biomaj
arch: src
version: 3.1.24
epoch: 0
release: 1
summary: BioMAJ
url: http://biomaj.genouest.org
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomaj-3.1.24-1.src.rpm
checksum_type: sha256
description:
  This project is a complete rewrite of BioMAJ and the documentation is available here : http://biomaj.genouest.org.
  BioMAJ (BIOlogie Mise A Jour) is a workflow engine dedicated to data
  synchronization and processing. The Software automates the update cycle and the
  supervision of the locally mirrored databank repository.
  Common usages are to download remote databanks (Genbank for example) and apply
  some transformations (blast indexing, emboss indexing, etc.). Any script can be
  applied on downloaded data. When all treatments are successfully applied, bank
  is put in "production" on a dedicated release directory.
  With cron tasks, update tasks can be executed at regular interval, data are
  downloaded again only if a change is detected.
  More documentation is available in wiki page.
  BioMAJ is python 2 and 3 compatible until release 3.1.17.
  After 3.1.17, only python 3 is supported.


pkgId: e50d2b2ae46f2a9fbfc413be824fb3705e72a6e16c71d452eba05ed1c4a79abf
name: python-biomaj-core
arch: src
version: 3.0.28
epoch: 0
release: 1
summary: BioMAJ core library
url: http://biomaj.genouest.org
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomaj-core-3.0.28-1.src.rpm
checksum_type: sha256
description:
  Biomaj core library


  Properties can be overriden by environment variables with pattern BIOMAJ_X_Y_Z for property x.y.z

  Example:

  use BIOMAJ_LDAP_HOST for ldap.host

  [![PyPI version](https://badge.fury.io/py/biomaj-core.svg)](https://badge.fury.io/py/biomaj-core)


  3.0.28:
     use pytest instead of nose (deprecated)
     python3 only support

  3.0.27:
     add .tgz extension support

  3.0.26:
     check use_ldap and use_elastic as bool (true/false or 0/1)

  3.0.25:
     utils/get_folder_size: if file not found, catch error and continue

  3.0.24:
     get_more_recent_file, return also file info

  3.0.23:
     PR #9 Add missing ssh defaults for download

  3.0.21 [3.0.22 ,tag issue]:
     Pin elasticsearch dependency, v7 breaks some API calls

  3.0.20:
     PR #7 from institut-de-genomique/retry_method, rename default values of retryer.
     Rename wait_condition to wait_policy in default values
     PR #6 from institut-de-genomique/retry_method, add default values for retryer
     Add default values for retryer (see the corresponding branch biomaj-download).

  3.0.19:
    Add ftps and directftps protocols
    
    copy_files_with_regexp: remove duplicates
    Add utils fonctions
    Code cleanup

  3.0.18:
    Allow to use hardlinks in copy_files and copy_files_with_regexp

  3.0.17:
    Fix --log option

  3.0.16:
    Add some warnings if some file is missing

  3.0.15:
    Fix check on bank properties config file when args is empty vs not defined

  3.0.14:
    Fix checks on local_endpoint_XXX in config.yml
    In rabbitmq not defined on config.yml add an empty dict

  3.0.13:
    Add archive integrity checks

  3.0.12:
    Add irods support

  3.0.11:
    Add get_module_version static method, checks module version and latest version on pypi
    Allow .args fo process to be empty

  3.0.10:
    Add env variables WEB_LOCAL_ENDPOINT_XX with XX as a service (defined in utils.py Utils.services) to define an endpoint per service

  3.0.9:
    

  3.0.8:
    Add DOCKER_URL, MONGO_URL, MONGO_DB env variable in override
    Do not fail on elasticsearch index creation, just log
    Add rsync check

  3.0.7:
    set logging only if necessary

  3.0.6:
    Fix configparser import for python 2 vs 3

  3.0.5:
    Add config override with env variables

  3.0.4:
    Code cleanup

  3.0.3:
    Put index management in core

  3.0.2:
    Add missing deps

  3.0.1:
    Add README etc..

  3.0.0:
    separation of biomaj and biomaj_core


pkgId: f3631f7cb4c832a4e5787bbb2ec08df48e44c9666ff81be566034189a5b3e42f
name: python-biomapper
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A unified Python toolkit for biological data harmonization and ontology mapping
url: https://github.com/arpanauts/biomapper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomapper-0.1.3-1.src.rpm
checksum_type: sha256
description:
  A unified Python toolkit for biological data harmonization and ontology mapping. `biomapper` provides a single interface for standardizing identifiers and mapping between various biological ontologies, making multi-omic data integration more accessible and reproducible.




  - **ID Standardization**: Unified interface for standardizing biological identifiers
  - **Ontology Mapping**: Comprehensive ontology mapping using major biological databases
  - **Data Validation**: Robust validation of input data and mappings
  - **Extensible Architecture**: Easy integration of new data sources and mapping services




  - BridgeDb
  - RefMet
  - RaMP-DB


  - UMLS Metathesaurus
  - Ontology Lookup Service (OLS)
  - BioPortal





  1. Install Python 3.11 with pyenv (if not already installed):
  ```bash

  sudo apt-get update
  sudo apt-get install -y make build-essential libssl-dev zlib1g-dev \
  libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev \
  libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev python3-openssl


  curl https://pyenv.run | bash


  echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
  echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
  echo 'eval "$(pyenv init -)"' >> ~/.bashrc


  source ~/.bashrc


  pyenv install 3.11.7
  pyenv local 3.11.7
  ```

  2. Install Poetry (if not already installed):
  ```bash
  curl -sSL https://install.python-poetry.org | python3 -


  echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
  source ~/.bashrc
  ```

  3. Clone and set up the project:
  ```bash
  git clone https://github.com/yourusername/biomapper.git
  cd biomapper


  poetry install
  ```



  ```python

  poetry shell

  from biomapper import AnalyteMetadata
  from biomapper.standardization import BridgeDBHandler


  metadata = AnalyteMetadata()


  bridge_handler = BridgeDBHandler()


  results = bridge_handler.standardize(["P12345", "Q67890"])
  ```





  ```bash

  poetry shell


  poetry run python script.py


  poetry add package-name


  poetry add --group dev package-name


  poetry update


  poetry show


  poetry build
  ```


  ```bash

  poetry run pytest


  poetry run pytest --cov=biomapper
  ```


  ```bash

  poetry run black .


  poetry run flake8 .


  poetry run mypy .
  ```



  ```
  biomapper/
  ├── biomapper/           # Main package directory
  │   ├── core/           # Core functionality
  │   │   ├── metadata.py # Metadata handling
  │   │   └── validators.py # Data validation
  │   ├── standardization/# ID standardization components
  │   ├── mapping/        # Ontology mapping components
  │   ├── utils/          # Utility functions
  │   └── schemas/        # Data schemas and models
  ├── tests/              # Test files
  ├── docs/               # Documentation
  ├── scripts/            # Utility scripts
  ├── pyproject.toml      # Poetry configuration and dependencies
  └── poetry.lock        # Lock file for dependencies
  ```



  This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.



  For support, please open an issue in the GitHub issue tracker.



  - [ ] Initial release with core functionality
  - [ ] Add support for additional ontology services
  - [ ] Implement caching layer
  - [ ] Add batch processing capabilities
  - [ ] Develop REST API interface



  - [BridgeDb](https://www.bridgedb.org/)
  - [RefMet](https://refmet.metabolomicsworkbench.org/)
  - [RaMP-DB](http://rampdb.org/)
  - [UMLS](https://www.nlm.nih.gov/research/umls/index.html)
  - [OLS](https://www.ebi.ac.uk/ols/index)
  - [BioPortal](https://bioportal.bioontology.org/)


pkgId: 1c830f78b438ef8c8b0cd2bfb15ac1b4dc54156aa52a200bb36df10bccebf309
name: python-biomappings
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Curated and predicted mappings between biomedical identifiers in different namespaces
url: https://github.com/biopragmatics/biomappings
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomappings-0.3.7-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/biopragmatics/biomappings/raw/master/docs/source/logo.png" height="150">
  </p>

  <h1 align="center">
    Biomappings
  </h1>

  <p align="center">
      <a href="https://github.com/biopragmatics/biomappings/actions?query=workflow%3A%22Check+mappings%22">
          <img alt="Check mappings" src="https://github.com/biopragmatics/biomappings/workflows/Check%20mappings/badge.svg" />
      </a>
      <a href="https://pypi.org/project/biomappings">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/biomappings" />
      </a>
      <a href="https://pypi.org/project/biomappings">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/biomappings" />
      </a>
      <a href="https://github.com/biopragmatics/biomappings/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/biomappings" />
      </a>
      <a href='https://biomappings.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/biomappings/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="https://zenodo.org/badge/latestdoi/285352907">
          <img src="https://zenodo.org/badge/285352907.svg" alt="DOI">
      </a>
      <a href="https://github.com/psf/black">
          <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
      </a>
      <a href="https://github.com/biopragmatics/bioregistry">
          <img alt="Powered by the Bioregistry" src="https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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" />
      </a>
      <a href="https://github.com/biopragmatics/biomappings/blob/master/docs/CODE_OF_CONDUCT.md">
          <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" />
      </a>
  </p>

  Biomappings is a repository of community curated and predicted equivalences and
  related mappings between named biological entities that are not available from
  primary sources. It's also a place where anyone can contribute curations
  of predicted mappings or their own novel mappings. Ultimately, we hope that
  primary resources will integrate these mappings and distribute them themselves.

  Mappings are stored in a simple TSV file that looks like this:

  ![](docs/img/mappings_screenshot.png)



  The data are available through the following four files on
  the [biopragmatics/biomappings](https://github.com/biopragmatics/biomappings) GitHub repository.

  | Curated | Description                                                  | Link                                                                                                                                             |
  | ------- |--------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
  |  Yes    | Human-curated true mappings                                  | [`src/biomappings/resources/mappings.tsv`](https://github.com/biopragmatics/biomappings/raw/master/src/biomappings/resources/mappings.tsv)       |
  |  Yes    | Human-curated *non-trivial* false (i.e., incorrect) mappings | [`src/biomappings/resources/incorrect.tsv`](https://github.com/biopragmatics/biomappings/raw/master/src/biomappings/resources/incorrect.tsv)     |
  |  Yes    | Mappings that have been checked but not yet decided          | [`src/biomappings/resources/unsure.tsv`](https://github.com/biopragmatics/biomappings/raw/master/src/biomappings/resources/unsure.tsv)           |
  |  No     | Automatically predicted mappings                             | [`src/biomappings/resources/predictions.tsv`](https://github.com/biopragmatics/biomappings/raw/master/src/biomappings/resources/predictions.tsv) |

  The primary and derived data in this repository are both available under
  the [CC0 1.0 Universal License](https://github.com/biopragmatics/biomappings/blob/master/LICENSE).

  Predictions are generated by scripts in the [`scripts/`](scripts) folder. Each
  uses the utilities from the `biomappings.resources` module to programmatically
  interact with the mappings files, e.g., to add predictions.



  The mappings are distributed in the [Simple Standard for Sharing Ontology Mappings
  (SSSOM)](https://github.com/mapping-commons/sssom) format
  ([here](https://github.com/biopragmatics/biomappings/blob/master/docs/_data/sssom))
  and can be referenced by PURL such as https://w3id.org/biopragmatics/biomappings/sssom/biomappings.sssom.tsv.
  The positive mappings are also available as a network through
  [NDEx](https://www.ndexbio.org/#/network/402d1fd6-49d6-11eb-9e72-0ac135e8bacf).

  Equivalences and related mappings that are available from the OBO Foundry and other primary sources can be accessed
  through [Inspector Javert's Xref Database](https://zenodo.org/record/3757266)
  on Zenodo which was described in [this blog post](https://cthoyt.com/2020/04/19/inspector-javerts-xref-database.html).



  Summary statistics of the manually curated mappings and predicted mappings
  are automatically generated nightly and deployed as a website with GitHub
  Actions to https://biopragmatics.github.io/biomappings.

  [![Summary statistics](docs/img/summary.svg)](https://biopragmatics.github.io/biomappings)



  We welcome contributions in the form of curations to any of the four primary TSV
  files in this repository via a pull request to the main Biomappings repository
  at https://github.com/biopragmatics/biomappings.

  Predicted mappings can be curated by moving a row in the `predictions.tsv` file
  into either the positive mappings file (`mappings.tsv`), negative mappings file
  (`incorrect.tsv`), or the unsure mappings file (`unsure.tsv`). Additionally,
  the `confidence` column should be removed, a `type` column should be added with
  the value `manually_reviewed`, and the `source` column should be changed from
  the prediction script's URI to your ORCiD identifier written as a CURIE
  (e.g., `orcid:0000-0003-1307-2508`).

  Novel mappings can be curated by adding a full row to the positive mappings
  file (`mappings.tsv`) following the format of the previous lines.

  While Biomappings is generally able to use any predicate written as a [compact URI (CURIE)](http://www.w3.org/TR/curie),
  it's preferred to use predicates from the [Simple Knowledge Organization System (SKOS)](https://www.w3.org/2004/02/skos/)
  to denote hierarchical relationships. The three most common predicates that are
  useful for curating mappings are:

  | Predicate                                                                             | Description                                     |
  |---------------------------------------------------------------------------------------|-------------------------------------------------|
  | [`skos:exactMatch`](https://www.w3.org/2009/08/skos-reference/skos.html#exactMatch)   | The two terms can be used interchangeably       |
  | [`skos:broadMatch`](https://www.w3.org/2009/08/skos-reference/skos.html#broadMatch)   | The object term is a super-class of the subject |
  | [`skos:narrowMatch`](https://www.w3.org/2009/08/skos-reference/skos.html#narrowMatch) | The object term is a sub-class of the subject   |



  GitHub has an interface for editing files directly in the browser. It will take care of creating a branch for you and
  creating a pull request. After logging into GitHub, click one of the following links to be brought to the editing
  interface:

  - [True Mappings](https://github.com/biopragmatics/biomappings/edit/master/src/biomappings/resources/mappings.tsv)
  - [False Mappings](https://github.com/biopragmatics/biomappings/edit/master/src/biomappings/resources/incorrect.tsv)
  - [Unsure Mappings](https://github.com/biopragmatics/biomappings/edit/master/src/biomappings/resources/unsure.tsv)
  - [Predictions](https://github.com/biopragmatics/biomappings/edit/master/src/biomappings/resources/predictions.tsv)

  This has the caveat that you can only edit one file at a time. It's possible to navigate to your own forked version of
  the repository after, to the correct branch (will not be the default one), then edit other files in the web interface as
  well. However, if you would like to do this, then it's probably better to see the following instructions on contributing
  locally.



  1. Fork the repository at https://github.com/biopragmatics/biomappings, clone locally, and make a new branch (see below)
  2. Edit one or more of the resource files (`mappings.tsv`, `incorrect.tsv`, `unsure.tsv`, `predictions.tsv`)
  3. Commit to your branch, push, and create a pull request back to the upstream repository.



  Rather than editing files locally, this repository also comes with a web-based curation interface. Install the code in
  development mode with the `web` option (which installs `flask` and `flask-bootstrap`) using:

  ```bash
  $ git clone git+https://github.com/biopragmatics/biomappings.git
  $ cd biomappings
  $ git checkout -b your-branch-name
  $ pip install -e .[web]
  ```

  The web application can be run with:

  ```bash
  $ biomappings web
  ```

  It can be accessed by navigating to http://localhost:5000/ in your browser.
  After you do some curations, the web application takes care of interacting with
  the git repository from which you installed `biomappings` via the "commit and
  push" button.

  **Note** if you've installed `biomappings` via [PyPI](https://pypi.org/project/biomappings/),
  then running the web curation interface doesn't make much sense,
  since it's non-trivial for most users to find the location of the resources within your Python installation's
  `site-packages` folder, and you won't be able to contribute them back.



  There are three places where curators of Biomappings are credited:

  1. ORCiD identifiers of curators are stored in each mapping
  2. The [summary website](https://biopragmatics.github.io/biomappings) groups
     and counts contributions curator
  3. A curation leaderboard is automatically uploaded to [APICURON](https://apicuron.org/database?resource_uri=https:%2F%2Fbiomappings.github.io%2Fbiomappings%2F).



  The most recent release can be installed from
  [PyPI](https://pypi.org/project/biomappings/) with:

  ```bash
  $ pip install biomappings
  ```

  The most recent code and data can be installed directly from GitHub with:

  ```bash
  $ pip install git+https://github.com/biopragmatics/biomappings.git
  ```

  To install in development mode and create a new branch, use the following:

  ```bash
  $ git clone git+https://github.com/biopragmatics/biomappings.git
  $ cd biomappings
  $ pip install -e .
  ```



  There are three main functions exposed from `biomappings`. Each loads a list of dictionaries with the mappings in each.

  ```python
  import biomappings

  true_mappings = biomappings.load_mappings()

  false_mappings = biomappings.load_false_mappings()

  predictions = biomappings.load_predictions()
  ```

  Alternatively, you can use the above links to the TSVs on GitHub in with the library or programming language of your
  choice.

  The data can also be loaded as [networkx](https://networkx.org/) graphs with the following functions:

  ```python
  import biomappings

  true_graph = biomappings.get_true_graph()

  false_graph = biomappings.get_false_graph()

  predictions_graph = biomappings.get_predictions_graph()
  ```

  Full documentation can be found on [ReadTheDocs](https://biomappings.readthedocs.io).





  Code is licensed under the MIT License. Data are licensed under the CC0 License.



  > [Prediction and Curation of Missing Biomedical Identifier Mappings with Biomappings](https://doi.org/10.1093/bioinformatics/btad130)
  > <br />Hoyt, C. T., Hoyt, A. L., and Gyori, B. M. (2022)
  > <br />*Bioinformatics*, btad130.

  ```bibtex
  @article{Hoyt2022,
     title = {{Prediction and Curation of Missing Biomedical Identifier Mappings with Biomappings}},
     author = {Hoyt, Charles Tapley and Hoyt, Amelia L and Gyori, Benjamin M},
     journal = {Bioinformatics},
     year = {2023},
     month = {03},
     issn = {1367-4811},
     doi = {10.1093/bioinformatics/btad130},
     url = {https://doi.org/10.1093/bioinformatics/btad130},
     note = {btad130},
     eprint = {https://academic.oup.com/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btad130/49521613/btad130.pdf},
  }
  ```



  Biomappings was developed by the [INDRA Lab](https://indralab.github.io), a part of the
  [Laboratory of Systems Pharmacology](https://hits.harvard.edu/the-program/laboratory-of-systems-pharmacology/about/)
  and the [Harvard Program in Therapeutic Science (HiTS)](https://hits.harvard.edu)
  at [Harvard Medical School](https://hms.harvard.edu/).



  The development of the Bioregistry is funded by the DARPA Young Faculty Award W911NF2010255 (PI:
  Benjamin M. Gyori).



  This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s
  [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s
  [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template.



  <details>
    <summary>See developer instructions</summary>


  The final section of the README is for if you want to get involved by making a code contribution.



  To install in development mode, use the following:

  ```bash
  $ git clone git+https://github.com/biopragmatics/biomappings.git
  $ cd biomappings
  $ pip install -e .
  ```



  After cloning the repository and installing `tox` with `pip install tox`, the unit tests in the `tests/` folder can be
  run reproducibly with:

  ```shell
  $ tox
  ```

  Additionally, these tests are automatically re-run with each commit in a [GitHub Action](https://github.com/biopragmatics/biomappings/actions?query=workflow%3ATests).



  The documentation can be built locally using the following:

  ```shell
  $ git clone git+https://github.com/biopragmatics/biomappings.git
  $ cd biomappings
  $ tox -e docs
  $ open docs/build/html/index.html
  ```

  The documentation automatically installs the package as well as the `docs`
  extra specified in the [`setup.cfg`](setup.cfg). `sphinx` plugins
  like `texext` can be added there. Additionally, they need to be added to the
  `extensions` list in [`docs/source/conf.py`](docs/source/conf.py).



  After installing the package in development mode and installing
  `tox` with `pip install tox`, the commands for making a new release are contained within the `finish` environment
  in `tox.ini`. Run the following from the shell:

  ```shell
  $ tox -e finish
  ```

  This script does the following:

  1. Uses [Bump2Version](https://github.com/c4urself/bump2version) to switch the version number in the `setup.cfg`,
     `src/biomappings/version.py`, and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel using [`build`](https://github.com/pypa/build)
  3. Uploads to PyPI using [`twine`](https://github.com/pypa/twine). Be sure to have a `.pypirc` file configured to avoid the need for manual input at this
     step
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion minor` after.
  </details>


pkgId: 54dd83bc5d3f5628265ab6b8fa9adf7753b4c537c3ee928d60c83cd5a442c350
name: python-biomass
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A Python Framework for Modeling and Analysis of Signaling Systems
url: https://pypi.org/project/biomass/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomass-0.14.0-1.src.rpm
checksum_type: sha256
description:
  <br>
  <p align="center">
      <a href="https://biomass-core.readthedocs.io/en/latest">
          <img src="https://raw.githubusercontent.com/biomass-dev/biomass/master/docs/_static/img/biomass-logo.png" width="400">
      </a>
  </p>

  [![PyPI version](https://img.shields.io/pypi/v/biomass.svg?logo=PyPI&logoColor=white)](https://pypi.python.org/pypi/biomass)
  [![Actions Status](https://github.com/biomass-dev/biomass/workflows/Tests/badge.svg)](https://github.com/biomass-dev/biomass/actions)
  [![Documentation Status](https://img.shields.io/readthedocs/biomass-core/latest.svg?logo=read%20the%20docs&logoColor=white&&label=Docs&version=latest)](https://biomass-core.readthedocs.io/en/latest/?badge=latest)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg?logo=apache)](https://opensource.org/licenses/Apache-2.0)
  [![Downloads](https://static.pepy.tech/badge/biomass)](https://pepy.tech/project/biomass)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/biomass.svg?logo=Python&logoColor=white)](https://pypi.python.org/pypi/biomass)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/biomass-dev/biomass/master.svg)](https://results.pre-commit.ci/latest/github/biomass-dev/biomass/master)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Paper](https://img.shields.io/badge/DOI-10.1093%2Fbioadv%2Fvbae042-blue)](https://doi.org/10.1093/bioadv/vbae042)

  _BioMASS_ is a computational framework for modeling and analysis of biological signaling systems in Python.

  - **Documentation:** https://biomass-core.rtfd.io
  - **Source code:** https://github.com/biomass-dev/biomass
  - **Bug reports:** https://github.com/biomass-dev/biomass/issues
  - **Citing in your work:** https://biomass-core.rtfd.io/en/latest/citing.html

  It provides useful tools for numerical simulation, parameter estimation, network analysis, and result visualization.



  The BioMASS library is available at the [Python Package Index (PyPI)](https://pypi.org/project/biomass).

  ```shell
  $ pip install biomass
  ```

  BioMASS supports Python 3.8 or newer.



  - Imoto, H., Zhang, S. & Okada, M. A Computational Framework for Prediction and Analysis of Cancer Signaling Dynamics from RNA Sequencing Data—Application to the ErbB Receptor Signaling Pathway. _Cancers_ **12**, 2878 (2020). https://doi.org/10.3390/cancers12102878

  - Imoto, H., Yamashiro, S. & Okada, M. A text-based computational framework for patient -specific modeling for classification of cancers. _iScience_ **25**, 103944 (2022). https://doi.org/10.1016/j.isci.2022.103944

  - Arakane, K., Imoto, H., Ormersbach, F. & Okada, M. Extending BioMASS to construct mathematical models from external knowledge. _Bioinformatics Advances_ **4**, vbae042 (2024). https://doi.org/10.1093/bioadv/vbae042



  [Hiroaki Imoto](https://github.com/himoto)



  [Apache License 2.0](https://github.com/biomass-dev/biomass/blob/master/LICENSE)


pkgId: 624f6898e2ae88fcda13d527df053bc4f134a15b8c3fbb7e1a5e6dbc4f27bd78
name: python-biomcp
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: MCP servers for bioinformatics
url: https://pypi.org/project/biomcp/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomcp-0.0.1-1.src.rpm
checksum_type: sha256
description:
  <!-- omit in toc -->


  <div align="center">

  <strong>The fast, Pythonic way to build MCP servers for bioinformatics.</strong>

  [![PyPI - Version](https://img.shields.io/pypi/v/biomcp.svg)](https://pypi.org/project/biomcp)
  [![Tests](https://github.com/biomcp/biomcp/actions/workflows/run-tests.yml/badge.svg)](https://github.com/biomcp/biomcp/actions/workflows/run-tests.yml)
  [![License](https://img.shields.io/github/license/biomcp/biomcp.svg)](https://github.com/biomcp/biomcp/blob/main/LICENSE)


  </div>


pkgId: a4373f9a7e931810cee8bae7510eed8e3ae42f390a16338221de7cf0cc91c6a2
name: python-biomed-multi-view
arch: src
version: 1.0
epoch: 0
release: 1
url: https://pypi.org/project/biomed-multi-view/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomed-multi-view-1.0-1.src.rpm
checksum_type: sha256
summary:
  This repository contains the implementation of the Multi-view Molecular Embedding with Late Fusion (MMELON) architecture.

description:
  This repository contains the implementation of the Multi-view Molecular Embedding with Late Fusion (MMELON) architecture presented in our preprint [Multi-view biomedical foundation models for molecule-target and property prediction](https://arxiv.org/abs/2410.19704). MMELON is a flexible approach to aggregate multiple views (sequence, image, graph) of molecules in a foundation model setting. While models based on single view representation typically performs well on some downstream tasks and not others, the multi-view model performs robustly across a wide range of property prediction tasks encompassing ligand-protein binding, molecular solubility, metabolism and toxicity. It has been applied to screen compounds against a large (> 100 targets) set of G Protein-Coupled receptors (GPCRs) to identify strong binders for 33 targets related to Alzheimer’s disease, which are validated through structure-based modeling and identification of key binding motifs.

  Our model integrates:

  * Image Representation: Captures the 2D visual depiction of molecular structures, highlighting features like symmetry, bond angles, and functional groups. Molecular images are generated using RDKit and undergo data augmentation during training to enhance robustness.
  * Graph Representation: Encodes molecules as undirected graphs where nodes represent atoms and edges represent bonds. Atom-specific properties (e.g., atomic number, chirality) and bond-specific properties (e.g., bond type, stereochemistry) are embedded using categorical embedding techniques.
  * Text Representation: Utilizes SMILES strings to represent chemical structures, tokenized with a custom tokenizer. The sequences are embedded using a transformer-based architecture to capture the sequential nature of the chemical information.

  The embeddings from these single-view pre-trained encoders are combined using an attention-based aggregator module. This module learns to weight each view appropriately, producing a unified multi-view embedding. This approach leverages the strengths of each representation to improve performance on downstream predictive tasks.

  ![MultiView diagram](docs/overview.png)

  _Figure: Schematic of multi-view architecture. Embeddings from three single view pre-trained encoders (Image, Graph and Text) are combined by the aggregator module into a combined embedding. The network is finetunable for downstream predictive tasks._

  Our pre-training dataset comprises 200 million molecules sourced from the PubChem and ZINC22 chemical databases, ensuring diversity and relevance to downstream tasks. Each view encoder is pre-trained with self-supervised tasks tailored to capture the unique features of its representation.

  MMELON’s extensible architecture allows for seamless integration of additional views, making it a versatile tool for molecular representation learning. For further details, see [here](https://arxiv.org/abs/2410.19704).





  1. [Demo Notebook for inference](notebooks/smmv_api_demo.ipynb)
  2. [Contributing code](CONTRIBUTING.md)


  Follow these steps to set up the `biomed-multi-view` codebase on your system.


  * Operating System: Linux or macOS
  * Python Version: Python 3.11
  * Conda: Anaconda or Miniconda installed
  * Git: Version control to clone the repository



  Choose a root directory where you want to install biomed.multi-view. For example:

  ```bash
  export ROOT_DIR=~/biomed-multiview
  mkdir -p $ROOT_DIR
  ```


  ```bash
  conda create -y python=3.11 --prefix $ROOT_DIR/envs/biomed-multiview
  ```
  Activate the environment:
  ```bash
  conda activate $ROOT_DIR/envs/biomed-multiview
  ```


  Navigate to the project directory and clone the repository:
  ```bash
  mkdir -p $ROOT_DIR/code
  cd $ROOT_DIR/code


  git clone https://github.com/BiomedSciAI/biomed-multi-view.git


  cd biomed-multi-view
  ```
  Note: If you prefer using SSH, ensure that your SSH keys are set up with GitHub and use the following command:
  ```bash
  git clone git@github.com:BiomedSciAI/biomed-multi-view.git
  ```


  If you are installing in a Mac, skip this step and proceed to next step. Else, install the package in editable mode along with development dependencies:
  ``` bash
  pip install -e .['dev']
  ```
  Install additional requirements:
  ``` bash
  pip install -r requirements.txt
  ```


  If you are using a Mac with Apple Silicon (M1/M2/M3) and the zsh shell, you may need to disable globbing for the installation command:

  ``` bash
  noglob pip install -e .[dev]
  ```
  Install macOS-specific requirements optimized for Apple’s Metal Performance Shaders (MPS):
  ```bash
  pip install -r requirements-mps.txt
  ```


  Verify that the installation was successful by running unit tests

  ```bash
  python -m unittest bmfm_sm.tests.all_tests
  ```


  Here’s a consolidated list of commands for quick reference:
  ```bash

  export ROOT_DIR=~/biomed-multiview
  mkdir -p $ROOT_DIR


  conda create -y python=3.11 --prefix $ROOT_DIR/envs/biomed-multiview
  conda activate $ROOT_DIR/envs/biomed-multiview


  mkdir -p $ROOT_DIR/code
  cd $ROOT_DIR/code
  git clone https://github.com/BiomedSciAI/biomed-multi-view.git
  cd biomed-multi-view


  pip install -e .[dev]
  pip install -r requirements.txt


  noglob pip install -e .[dev]
  pip install -r requirements-mps.txt


  python -m unittest bmfm_sm.tests.all_tests
  ```



  To explore the pretrained and finetuned models, please refer to the [demo notebook](notebooks/smmv_api_demo.ipynb). This notebook provides detailed examples and explanations on how to use the models effectively. You can launch the notebook from running the following command from a new terminal window.

  ```bash
  cd $ROOT_DIR/code/biomed-multi-view
  jupyter lab
  ```
  Copy the URL displayed on the console and paste it on a browser tab. The URL should look something similar to the below
  ```bash
  http://localhost:8888/lab?token=67f8a92c257a82010b4f82b219f7c1ad675ee329e730321e
  ```
  Navigate to the notebooks directory in the sidepanel in the Jupyter Lab GUI to locate the notebook named `smmv_api_demo.ipynb`.



  You can generate embeddings for a given molecule using the pretrained model with the following code. You can excute from cell 1 to 5 in the notebook run the same.

  ``` python
  from bmfm_sm.api.smmv_api import SmallMoleculeMultiViewModel


  example_smiles = "CC(C)CC1=CC=C(C=C1)C(C)C(=O)O"


  example_emb = SmallMoleculeMultiViewModel.get_embeddings(
      smiles=example_smiles,
      model_path="ibm/biomed.sm.mv-te-84m",
      huggingface=True,
  )
  print(example_emb)
  ```

  This will output the embedding vector for the given molecule.


  You can use the finetuned models to make predictions on new data. You can execute through cell 6 to 8 in the notebook to run the same.

  ``` python
  from bmfm_sm.api.smmv_api import SmallMoleculeMultiViewModel
  from bmfm_sm.api.dataset_registry import DatasetRegistry


  dataset_registry = DatasetRegistry()


  example_smiles = "CC(C)CC1=CC=C(C=C1)C(C)C(=O)O"


  bace_ds = dataset_registry.get_dataset_info('BACE')


  finetuned_model_ds = SmallMoleculeMultiViewModel.from_finetuned(
      bace_ds,
      model_path="ibm/biomed.sm.mv-te-84m-MoleculeNet-ligand_scaffold-BACE-101",
      inference_mode=True,
      huggingface=True
  )


  bace_prediction = SmallMoleculeMultiViewModel.get_predictions(
      example_smiles, bace_ds, finetuned_model=finetuned_model_bace
  )

  print("BACE Prediction:", bace_prediction)
  ```


  ```bash
  BACE Prediction: {'prediction': tensor(0, dtype=torch.int32)}
  ```
  Note: The outputs are illustrative. Actual predictions may vary depending on the model and data. For more detailed examples and explanations, please refer to the [demo notebook](notebooks/smmv_api_demo.ipynb) cell 8.


  To evaluate and train the models, you need to set up the necessary data, splits, configuration files, and model checkpoints. This section will guide you through the process.


  First, create a directory to serve as your root directory for all the data. This directory will house all datasets, splits, configuration files, and model checkpoints.
  ```bash
  mkdir -p $ROOT_DIR/data_root
  ```


  Set the `$BMFM_HOME` environment variable to point to your data root directory. This helps the scripts locate your data.
  ```bash
  export BMFM_HOME=$ROOT_DIR/data_root
  ```
  Optionally, add the export command to your shell configuration file (e.g., $HOME/.bashrc for bash):
  ```bash
  echo 'export BMFM_HOME=$ROOT_DIR/data_root' >> $HOME/.bashrc
  ```


  We provide all the necessary data splits, configuration files, and model checkpoints in a single archive to simplify the setup process.

  * Download `data_root_os_v1.tar.gz`: from [this location](https://ad-prod-biomed.s3.us-east-1.amazonaws.com/biomed.multi-view/data_root_os_v1.tar.gz).
  * Extract the Archive: 	Uncompress the tar file into your data root directory
    ```bash
    tar -xzvf data_root_os_v1.tar.gz -C $BMFM_HOME
    ```
  This will populate `$BMFM_HOME` with the required files and directories.


  We provide a script to download the MoleculeNet datasets automatically that you can run:
  ```bash
  run-download-moleculenet
  ```
  This script will download the MoleculeNet datasets into `$BMFM_HOME/datasets/raw_data/MoleculeNet/`. **Note**: The `run-download-moleculenet` command launches a Python script that can be executed using `bmfm_sm.python -m bmfm_sm.launch.download_molecule_net_data` from `$ROOT_DIR/code/biomed-multi-view` directory as well.


  After completing the above steps, your `$BMFM_HOME` directory should have the following structure:
  ```bash
  $BMFM_HOME/
  ├── bmfm_model_dir
  │   ├── finetuned
  │   │   └── MULTIVIEW_MODEL
  │   │       └── MoleculeNet
  │   │           └── ligand_scaffold
  │   └── pretrained
  │       └── MULTIVIEW_MODEL
  │           ├── biomed-smmv-base.pth
  │           └── biomed-smmv-with-coeff-agg.pth
  ├── configs_finetune
  │   └── MULTIVIEW_MODEL
  │       └── MoleculeNet
  │           └── ligand_scaffold
  │               ├── BACE
  │               ├── BBBP
  │               ├── CLINTOX
  │               ├── ESOL
  │               ├── FREESOLV
  │               ├── HIV
  │               ├── LIPOPHILICITY
  │               ├── MUV
  │               ├── QM7
  │               ├── SIDER
  │               ├── TOX21
  │               └── TOXCAST
  └── datasets
      ├── raw_data
      │   └── MoleculeNet
      │       ├── bace.csv
      │       ├── bbbp.csv
      │       ├── clintox.csv
      │       ├── esol.csv
      │       ├── freesolv.csv
      │       ├── hiv.csv
      │       ├── lipophilicity.csv
      │       ├── muv.csv
      │       ├── qm7.csv
      │       ├── qm9.csv
      │       ├── sider.csv
      │       ├── tox21.csv
      │       └── toxcast.csv
      └── splits
          └── MoleculeNet
              └── ligand_scaffold
                  ├── bace_split.json
                  ├── bbbp_split.json
                  ├── clintox_split.json
                  ├── esol_split.json
                  ├── freesolv_split.json
                  ├── hiv_split.json
                  ├── lipophilicity_split.json
                  ├── muv_split.json
                  ├── qm7_split.json
                  ├── sider_split.json
                  ├── tox21_split.json
                  └── toxcast_split.json
  ```

  After successfully completing the installation and data preparation steps, you are now ready to:

  * Usage: Learn how to obtain embeddings from the pretrained model.
  * Evaluation: Assess the model’s performance on benchmark datasets using our pretrained checkpoints.
  * Training: Understand how to finetune the pretrained model using the provided configuration files.
  * Inference: Run the model on sample data in inference mode to make predictions.



  We provide the `run-finetune` command for running finetuning and evaluation processes. You can use this command to evaluate the performance of the finetuned models on various datasets. **Note**: The `run-finetune` command launches a Python script that can be executed using `bmfm_sm.python -m launch.download_molecule_net_data` from `$ROOT_DIR/code/biomed-multi-view` directory as well.

  To see the usage options for the script, run:
  ```bash
  run-finetune --help
  ```

  This will display:
  ``` bash
  Usage: run-finetune [OPTIONS]

  Options:
    --model TEXT           Model name
    --dataset-group TEXT   Dataset group name
    --split-strategy TEXT  Split strategy name
    --dataset TEXT         Dataset name
    --fit                  Run training (fit)
    --test                 Run testing
    -o, --override TEXT    Override parameters in key=value format (e.g.,
                           trainer.max_epochs=10)
    --help                 Show this message and exit.
  ```

  To evaluate a finetuned checkpoint on a specific dataset, use the --test option along with the --dataset parameter. For example, to evaluate on the BBBP dataset:

  ``` bash
  python run-finetune --test --dataset BBBP
  ```
  If you omit the `--dataset` option, the script will prompt you to choose a dataset:
  ```bash
  python run-finetune --test
  Please choose a dataset (FREESOLV, BBBP, CLINTOX, MUV, TOXCAST, QM9, BACE, LIPOPHILICITY, ESOL, HIV, TOX21, SIDER, QM7): BBBP
  ```
  This command will evaluate the finetuned checkpoint corresponding to the BBBP dataset using the test set of the `ligand_scaffold` split.



  To finetune the pretrained model on a specific dataset, use the --fit option:

  ``` bash
  python run-finetune --fit --dataset BBBP
  ```
  Again, if you omit the --dataset option, the script will prompt you to select one:

  ```bash
  python run-finetune --fit
  Please choose a dataset (FREESOLV, BBBP, CLINTOX, MUV, TOXCAST, QM9, BACE, LIPOPHILICITY, ESOL, HIV, TOX21, SIDER, QM7): BBBP
  ```
  This command will start the finetuning process for the BBBP dataset using the configuration files provided in the `configs_finetune` directory.

  Note: You can override default parameters using the `-o` or `--override` option. For example:

  ```bash
  python run-finetune --fit --dataset BBBP -o trainer.max_epochs=10
  ```

  **Note**: If you run into out of memory errors, you can reduce the batch size using the following syntax

  ```bash
  python run-finetune --fit --dataset BBBP -o data.init_args.batch_size=4
  ```



  ```
  @misc{suryanarayanan2024multiviewbiomedicalfoundationmodels,
        title={Multi-view biomedical foundation models for molecule-target and property prediction},
        author={Parthasarathy Suryanarayanan and Yunguang Qiu and Shreyans Sethi and Diwakar Mahajan and Hongyang Li and Yuxin Yang and Elif Eyigoz and Aldo Guzman Saenz and Daniel E. Platt and Timothy H. Rumbell and Kenney Ng and Sanjoy Dey and Myson Burch and Bum Chul Kwon and Pablo Meyer and Feixiong Cheng and Jianying Hu and Joseph A. Morrone},
        year={2024},
        eprint={2410.19704},
        archivePrefix={arXiv},
        primaryClass={q-bio.BM},
        url={https://arxiv.org/abs/2410.19704},
  }
  ```


pkgId: a6bd002475eb735a03bc769061ce4b4506de8221ffc14e7bceca257814f8e5cb
name: python-biomedisa
arch: src
version: 24.8.5
epoch: 0
release: 1
summary: Segmentation of 3D volumetric image data
url: https://biomedisa.info
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomedisa-24.8.5-1.src.rpm
checksum_type: sha256
description:
  - [Overview](#overview)
  - [Hardware Requirements](#hardware-requirements)
  - [Installation (command-line based)](#installation-command-line-based)
  - [Installation (browser based)](#installation-browser-based)
  - [Download Data](#download-data)
  - [Revisions](#revisions)
  - [Quickstart](#quickstart)
  - [Smart Interpolation](#smart-interpolation)
  - [Deep Learning](#deep-learning)
  - [Mesh Generator](#mesh-generator)
  - [Biomedisa Features](#biomedisa-features)
  - [Authors](#authors)
  - [FAQ](#faq)
  - [Citation](#citation)
  - [License](#license)

  Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large 3D volumetric images such as CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's smart interpolation of sparsely pre-segmented slices enables accurate semi-automated segmentation by considering the complete underlying image data. Additionally, Biomedisa enables deep learning for fully automated segmentation across similar samples and structures. It is compatible with segmentation tools like Amira/Avizo, ImageJ/Fiji and 3D Slicer. If you are using Biomedisa or the data for your research please cite: Lösel, P.D. et al. [Introducing Biomedisa as an open-source online platform for biomedical image segmentation.](https://www.nature.com/articles/s41467-020-19303-w) *Nat. Commun.* **11**, 5577 (2020).

  + One or more NVIDIA GPUs with compute capability 3.0 or higher.

  + [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
  + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
  + [Windows 10 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
  + [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)

  + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
  + [Windows 10 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)

  + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)

  + Download test data from our [gallery](https://biomedisa.info/gallery/)

  24.7.1
  + 3D Slicer extension
  + Prediction of large data block by block
  24.5.22
  + Pip is the preferred installation method
  + Commands, module names and imports have been changed to conform to the Pip standard
  + For versions <=23.9.1 please check [README](https://github.com/biomedisa/biomedisa/blob/master/README/deprecated/README_2023.09.1.md)

  Install the Biomedisa package from the [Python Package Index](https://pypi.org/project/biomedisa/):
  ```
  python -m pip install -U biomedisa
  ```
  For smart interpolation and deep Learning modules, follow the installation instructions above.

  + [Parameters and Examples](https://github.com/biomedisa/biomedisa/blob/master/README/smart_interpolation.md)

  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data
  from biomedisa.interpolation import smart_interpolation

  img, _ = load_data('Downloads/trigonopterus.tif')
  labels, header = load_data('Downloads/labels.trigonopterus_smart.am')

  results = smart_interpolation(img, labels, smooth=100)

  regular_result = results['regular']
  smooth_result = results['smooth']

  save_data('Downloads/final.trigonopterus.am', regular_result, header=header)
  save_data('Downloads/final.trigonopterus.smooth.am', smooth_result, header=header)
  ```

  ```
  python -m biomedisa.interpolation C:\Users\%USERNAME%\Downloads\tumor.tif C:\Users\%USERNAME%\Downloads\labels.tumor.tif
  ```
  If pre-segmentation is not exclusively in the XY plane:
  ```
  python -m biomedisa.interpolation C:\Users\%USERNAME%\Downloads\tumor.tif C:\Users\%USERNAME%\Downloads\labels.tumor.tif --allaxis
  ```

  + [Parameters and Examples](https://github.com/biomedisa/biomedisa/blob/master/README/deep_learning.md)

  ```python
  from biomedisa.features.biomedisa_helper import load_data
  from biomedisa.deeplearning import deep_learning

  img1, _ = load_data('Head1.am')
  img2, _ = load_data('Head2.am')
  img_data = [img1, img2]

  label1, _ = load_data('Head1.labels.am')
  label2, header, ext = load_data('Head2.labels.am',
          return_extension=True)
  label_data = [label1, label2]

  img3, _ = load_data('Head3.am')
  img4, _ = load_data('Head4.am')
  label3, _ = load_data('Head3.labels.am')
  label4, _ = load_data('Head4.labels.am')
  val_img_data = [img3, img4]
  val_label_data = [label3, label4]

  deep_learning(img_data, label_data, train=True, batch_size=12,
          val_img_data=val_img_data, val_label_data=val_label_data,
          header=header, extension=ext, path_to_model='honeybees.h5')
  ```

  ```
  python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t
  ```
  Monitor training progress using validation data:
  ```
  python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t -vi=C:\Users\%USERNAME%\Downloads\val_img -vl=C:\Users\%USERNAME%\Downloads\val_labels
  ```
  If running into ResourceExhaustedError due to out of memory (OOM), try to use a smaller batch size (e.g. -bs=12).

  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data
  from biomedisa.deeplearning import deep_learning

  img, _ = load_data('Head5.am')

  results = deep_learning(img, predict=True,
          path_to_model='honeybees.h5', batch_size=6)

  save_data('final.Head5.am', results['regular'], results['header'])
  ```

  ```
  python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\testing_axial_crop_pat13.nii.gz C:\Users\%USERNAME%\Downloads\heart.h5 -p
  ```

  + [Parameters and Examples](https://github.com/biomedisa/biomedisa/blob/master/README/save_mesh.md)

  Create STL mesh from segmentation (label values are saved as attributes)
  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data
  from biomedisa.mesh import get_voxel_spacing, save_mesh

  data, header, extension = load_data('final.Head5.am', return_extension=True)

  x_res, y_res, z_res = get_voxel_spacing(header, extension)
  print(f'Voxel spacing: x_spacing, y_spacing, z_spacing = {x_res}, {y_res}, {z_res}')

  save_mesh('final.Head5.stl', data, x_res, y_res, z_res, poly_reduction=0.9, smoothing_iterations=15)
  ```

  ```
  python -m biomedisa.mesh 'final.Head5.am'
  ```


  For DICOM, PNG files, or similar formats, file path must reference either a directory or a ZIP file containing the image slices.
  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data

  data, header = load_data('temp.tif')

  save_data('temp.tif', data, header)
  ```

  ```python
  from biomedisa.features.biomedisa_helper import img_resize

  zsh, ysh, xsh = data.shape
  new_zsh, new_ysh, new_xsh = zsh//2, ysh//2, xsh//2
  data = img_resize(data, new_zsh, new_ysh, new_xsh)

  label_data = img_resize(label_data, new_zsh, new_ysh, new_xsh, labels=True)
  ```

  ```python
  from biomedisa.features.biomedisa_helper import clean, fill

  label_data = clean(label_data, 0.9)

  label_data = fill(label_data, 0.9)
  ```

  ```python
  from biomedisa.features.biomedisa_helper import Dice_score, ASSD
  dice = Dice_score(ground_truth, result)
  assd = ASSD(ground_truth, result)
  ```

  * **Philipp D. Lösel**
  See also the list of [contributors](https://github.com/biomedisa/biomedisa/blob/master/credits.md) who participated in this project.

  Frequently asked questions can be found at: https://biomedisa.info/faq/.

  If you use Biomedisa or the data, please cite the following paper:
  `Lösel, P.D. et al. Introducing Biomedisa as an open-source online platform for biomedical image segmentation. Nat. Commun. 11, 5577 (2020).` https://doi.org/10.1038/s41467-020-19303-w
  If you use Biomedisa's Deep Learning, you may also cite:
  `Lösel, P.D. et al. Natural variability in bee brain size and symmetry revealed by micro-CT imaging and deep learning. PLoS Comput. Biol. 19, e1011529 (2023).` https://doi.org/10.1371/journal.pcbi.1011529
  If you use Biomedisa's Smart Interpolation, you can also cite the initial description of this method:
  `Lösel, P. & Heuveline, V. Enhancing a diffusion algorithm for 4D image segmentation using local information. Proc. SPIE 9784, 97842L (2016).` https://doi.org/10.1117/12.2216202

  This project is covered under the **EUROPEAN UNION PUBLIC LICENCE v. 1.2 (EUPL)**.


pkgId: 0f3233169c43838645b17d2b5bc61ba552117c8b4b185c5c5296e5f954eecfb2
name: python-biomedisa
arch: src
version: 24.8.6
epoch: 0
release: 1
summary: Segmentation of 3D volumetric image data
url: https://biomedisa.info
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomedisa-24.8.6-1.src.rpm
checksum_type: sha256
description:
  - [Overview](#overview)
  - [Hardware Requirements](#hardware-requirements)
  - [Installation (command-line based)](#installation-command-line-based)
  - [Installation (browser based)](#installation-browser-based)
  - [Download Data](#download-data)
  - [Revisions](#revisions)
  - [Quickstart](#quickstart)
  - [Smart Interpolation](#smart-interpolation)
  - [Deep Learning](#deep-learning)
  - [Mesh Generator](#mesh-generator)
  - [Biomedisa Features](#biomedisa-features)
  - [Authors](#authors)
  - [FAQ](#faq)
  - [Citation](#citation)
  - [License](#license)

  Biomedisa (https://biomedisa.info) is a free and easy-to-use open-source application for segmenting large 3D volumetric images such as CT and MRI scans, developed at [The Australian National University CTLab](https://ctlab.anu.edu.au/). Biomedisa's smart interpolation of sparsely pre-segmented slices enables accurate semi-automated segmentation by considering the complete underlying image data. Additionally, Biomedisa enables deep learning for fully automated segmentation across similar samples and structures. It is compatible with segmentation tools like Amira/Avizo, ImageJ/Fiji and 3D Slicer. If you are using Biomedisa or the data for your research please cite: Lösel, P.D. et al. [Introducing Biomedisa as an open-source online platform for biomedical image segmentation.](https://www.nature.com/articles/s41467-020-19303-w) *Nat. Commun.* **11**, 5577 (2020).

  + One or more NVIDIA GPUs with compute capability 3.0 or higher.

  + [Ubuntu 22.04 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_interpolation_cli.md)
  + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_cli.md)
  + [Windows 10/11 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_cli.md)
  + [Windows (WSL) + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/windows_wsl.md)

  + [Ubuntu 22.04 + Smart Interpolation + Deep Learning](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8_gpu_slicer.md)
  + [Windows 10/11 + Smart Interpolation](https://github.com/biomedisa/biomedisa/blob/master/README/windows10_cuda_gpu_slicer.md)

  + [Ubuntu 22.04](https://github.com/biomedisa/biomedisa/blob/master/README/ubuntu2204_cuda11.8.md)

  + Download test data from our [gallery](https://biomedisa.info/gallery/)

  24.7.1
  + 3D Slicer extension
  + Prediction of large data block by block
  24.5.22
  + Pip is the preferred installation method
  + Commands, module names and imports have been changed to conform to the Pip standard
  + For versions <=23.9.1 please check [README](https://github.com/biomedisa/biomedisa/blob/master/README/deprecated/README_2023.09.1.md)

  Install the Biomedisa package from the [Python Package Index](https://pypi.org/project/biomedisa/):
  ```
  python -m pip install -U biomedisa
  ```
  For smart interpolation and deep Learning modules, follow the installation instructions above.

  + [Parameters and Examples](https://github.com/biomedisa/biomedisa/blob/master/README/smart_interpolation.md)

  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data
  from biomedisa.interpolation import smart_interpolation

  img, _ = load_data('Downloads/trigonopterus.tif')
  labels, header = load_data('Downloads/labels.trigonopterus_smart.am')

  results = smart_interpolation(img, labels, smooth=100)

  regular_result = results['regular']
  smooth_result = results['smooth']

  save_data('Downloads/final.trigonopterus.am', regular_result, header=header)
  save_data('Downloads/final.trigonopterus.smooth.am', smooth_result, header=header)
  ```

  ```
  python -m biomedisa.interpolation C:\Users\%USERNAME%\Downloads\tumor.tif C:\Users\%USERNAME%\Downloads\labels.tumor.tif
  ```
  If pre-segmentation is not exclusively in the XY plane:
  ```
  python -m biomedisa.interpolation C:\Users\%USERNAME%\Downloads\tumor.tif C:\Users\%USERNAME%\Downloads\labels.tumor.tif --allaxis
  ```

  + [Parameters and Examples](https://github.com/biomedisa/biomedisa/blob/master/README/deep_learning.md)

  ```python
  from biomedisa.features.biomedisa_helper import load_data
  from biomedisa.deeplearning import deep_learning

  img1, _ = load_data('Head1.am')
  img2, _ = load_data('Head2.am')
  img_data = [img1, img2]

  label1, _ = load_data('Head1.labels.am')
  label2, header, ext = load_data('Head2.labels.am',
          return_extension=True)
  label_data = [label1, label2]

  img3, _ = load_data('Head3.am')
  img4, _ = load_data('Head4.am')
  label3, _ = load_data('Head3.labels.am')
  label4, _ = load_data('Head4.labels.am')
  val_img_data = [img3, img4]
  val_label_data = [label3, label4]

  deep_learning(img_data, label_data, train=True, batch_size=12,
          val_img_data=val_img_data, val_label_data=val_label_data,
          header=header, extension=ext, path_to_model='honeybees.h5')
  ```

  ```
  python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t
  ```
  Monitor training progress using validation data:
  ```
  python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\training_heart C:\Users\%USERNAME%\Downloads\training_heart_labels -t -vi=C:\Users\%USERNAME%\Downloads\val_img -vl=C:\Users\%USERNAME%\Downloads\val_labels
  ```
  If running into ResourceExhaustedError due to out of memory (OOM), try to use a smaller batch size (e.g. -bs=12).

  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data
  from biomedisa.deeplearning import deep_learning

  img, _ = load_data('Head5.am')

  results = deep_learning(img, predict=True,
          path_to_model='honeybees.h5', batch_size=6)

  save_data('final.Head5.am', results['regular'], results['header'])
  ```

  ```
  python -m biomedisa.deeplearning C:\Users\%USERNAME%\Downloads\testing_axial_crop_pat13.nii.gz C:\Users\%USERNAME%\Downloads\heart.h5 -p
  ```

  + [Parameters and Examples](https://github.com/biomedisa/biomedisa/blob/master/README/save_mesh.md)

  Create STL mesh from segmentation (label values are saved as attributes)
  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data
  from biomedisa.mesh import get_voxel_spacing, save_mesh

  data, header, extension = load_data('final.Head5.am', return_extension=True)

  x_res, y_res, z_res = get_voxel_spacing(header, extension)
  print(f'Voxel spacing: x_spacing, y_spacing, z_spacing = {x_res}, {y_res}, {z_res}')

  save_mesh('final.Head5.stl', data, x_res, y_res, z_res, poly_reduction=0.9, smoothing_iterations=15)
  ```

  ```
  python -m biomedisa.mesh 'final.Head5.am'
  ```


  For DICOM, PNG files, or similar formats, file path must reference either a directory or a ZIP file containing the image slices.
  ```python
  from biomedisa.features.biomedisa_helper import load_data, save_data

  data, header = load_data('temp.tif')

  save_data('temp.tif', data, header)
  ```

  ```python
  from biomedisa.features.biomedisa_helper import img_resize

  zsh, ysh, xsh = data.shape
  new_zsh, new_ysh, new_xsh = zsh//2, ysh//2, xsh//2
  data = img_resize(data, new_zsh, new_ysh, new_xsh)

  label_data = img_resize(label_data, new_zsh, new_ysh, new_xsh, labels=True)
  ```

  ```python
  from biomedisa.features.biomedisa_helper import clean, fill

  label_data = clean(label_data, 0.9)

  label_data = fill(label_data, 0.9)
  ```

  ```python
  from biomedisa.features.biomedisa_helper import Dice_score, ASSD
  dice = Dice_score(ground_truth, result)
  assd = ASSD(ground_truth, result)
  ```

  * **Philipp D. Lösel**
  See also the list of [contributors](https://github.com/biomedisa/biomedisa/blob/master/credits.md) who participated in this project.

  Frequently asked questions can be found at: https://biomedisa.info/faq/.

  If you use Biomedisa or the data, please cite the following paper:
  `Lösel, P.D. et al. Introducing Biomedisa as an open-source online platform for biomedical image segmentation. Nat. Commun. 11, 5577 (2020).` https://doi.org/10.1038/s41467-020-19303-w
  If you use Biomedisa's Deep Learning, you may also cite:
  `Lösel, P.D. et al. Natural variability in bee brain size and symmetry revealed by micro-CT imaging and deep learning. PLoS Comput. Biol. 19, e1011529 (2023).` https://doi.org/10.1371/journal.pcbi.1011529
  If you use Biomedisa's Smart Interpolation, you can also cite the initial description of this method:
  `Lösel, P. & Heuveline, V. Enhancing a diffusion algorithm for 4D image segmentation using local information. Proc. SPIE 9784, 97842L (2016).` https://doi.org/10.1117/12.2216202

  This project is covered under the **EUROPEAN UNION PUBLIC LICENCE v. 1.2 (EUPL)**.


pkgId: 1fa347a497473d78038eb4186a0d600ad8618cfc43231909e7a27d13b0d04902
name: python-biomedsheets
arch: src
version: 0.11.7
epoch: 0
release: 1
summary: Python 3 library for accessing and managing BioMedical sheets
url: https://github.com/bihealth/biomedsheets
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomedsheets-0.11.7-1.src.rpm
checksum_type: sha256
description:
  [![readthedocs](https://readthedocs.org/projects/biomedsheets/badge/?version=master)](https://biomedsheets.readthedocs.io/en/master)




  This project contains the documentation for the BioMedical sample sheets project.
  Further, it contains the implementation of a Python API for I/O and comfortable access to the sample sheets and some CLI tools.



  It's best to start a new virtualenv

  ```
  $ virtualenv -p python3 venv
  $ source venv/bin/activate
  $ pip install -r requirements/dev.txt
  $ pip install -e .
  ```

  Use `python setup.py install` if you want to copy the files instead of creating a link only.



  After installation (`requirements_dev.txt` contains the appropriate Sphinx version).

  ```
  $ cd docs
  $ make clean html
  ```

  Now, open `docs/build/html/index.html`.



  ```
  $ py.test
  ```









  * MANIFEST.in file for CHANGELOG.md ([#32](https://www.github.com/bihealth/biomedsheets/issues/32)) ([c093555](https://www.github.com/bihealth/biomedsheets/commit/c093555c937bd65d2c0cd3f06f62fd404e5364fd))






  * implementing release-please ([#30](https://www.github.com/bihealth/biomedsheets/issues/30)) ([2076440](https://www.github.com/bihealth/biomedsheets/commit/20764408458898b1f65cc550f5c1ae0514657b12))



  -   Fixing consistency check for Duo Cases (#26).



  -   Fixing issues with ResourceAdapter (#21).



  -   Fixing warnings in the tests (#19).



  -   Updating/modernizing dependencies.



  -   Adding property to shortcut sheets that indicates available kwargs.



  -   Adding custom option to join pedigrees by fields such as `familyId`.



  -   Adding functionality for filtering pedigrees.



  -   Fixing sorting bug.



  -   Sorting donors for picking the index in germline sample sheets.



  -   Fixing mapping of `Unknown` values.



  -   Changed behaviour in case of no affected donor has library. In this
      case, the first donor becomes the index. Consequently, the index
      must have an NGS library.



  -   Removing superflous print.



  -   Allowing to specify `bioSample` and `testSample` in germline TSV
      files.
  -   Fixing some tests.



  -   Proper merging with recent `ruamel.yaml` updates.



  -   Interpreting `#` in TSV files in more locations.



  -   Allowing to comment out lines in TSV files by prefixing them with
      `#`.



  -   Fixing bug in computing index (for real).



  -   Fixing bug in computing index.



  -   Fixing `setup.py` to work with pip v10.t



  -   Fixing packaging to use base and not test dependencies.



  -   Removing some hard (transitive) dependencies.



  -   Fixing manifest so the package contains the JSON file.



  -   Allow cancer sheets for use in germline calling.
  -   Only warn if index has no NGS library, no error.



  -   Fixin TSV I/O.
  -   Bumping ruamel.yaml version.
  -   Fixing cancer sheet iteration.
  -   Allowing cancer-only samples in cance case sheets.
  -   Fixing `float`-related bug.
  -   Fixing bug in reference resolving (+tests)



  -   Fixing `setup.py` to work with pip v10.



  -   Adding possibility for generic TSV sample sheets.
  -   Many updates to make documentation more clear.
  -   Various updates, fixing Codacy issues.
  -   Adding routines for writing out PED file from germline sample
      sheets.



  -   Auto-deployment to pypi
  -   Fixing shortcuts to father/mother during cohort loading
  -   Cleanup code (according to Flake 8)
  -   Adding more tests, replacing examples by TSV files
  -   Removing protein pools
  -   Adding Sphinx-based ocumentation
  -   Restructuring requirements txt files
  -   Configurable entity name generation. This allows to use secondary id
      only for naming, e.g.
  -   Fixing `requirements*.txt` files for always using SSH
  -   Fixing sample naming for germline sample sheets
  -   Adding versioneer integration



  -   First actual release, versioning done using versioneer
  -   Everything is new!


pkgId: f44608f7ff587a572e2ff758da225097f28a8748259e41498d12999ed1a7c94d
name: python-biomero
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: A python library for easy connecting between OMERO (jobs) and a Slurm cluster
url: https://github.com/NL-BioImaging/biomero
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomero-1.14.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![DOI](https://zenodo.org/badge/638954891.svg)](https://zenodo.org/badge/latestdoi/638954891) [![PyPI - Version](https://img.shields.io/pypi/v/biomero)](https://pypi.org/project/biomero/) [![PyPI - Python Versions](https://img.shields.io/pypi/pyversions/biomero)](https://pypi.org/project/biomero/) ![Slurm](https://img.shields.io/badge/Slurm-21.08.6-blue.svg) ![OMERO](https://img.shields.io/badge/OMERO-5.6.8-blue.svg) [![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green)](https://fair-software.eu) [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7530/badge)](https://bestpractices.coreinfrastructure.org/projects/7530) [![Sphinx build](https://github.com/NL-BioImaging/biomero/actions/workflows/sphinx.yml/badge.svg?branch=main)](https://github.com/NL-BioImaging/biomero/actions/workflows/sphinx.yml) [![pages-build-deployment](https://github.com/NL-BioImaging/biomero/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/NL-BioImaging/biomero/actions/workflows/pages/pages-build-deployment) [![python-package build](https://github.com/NL-BioImaging/biomero/actions/workflows/python-package.yml/badge.svg)](https://github.com/NL-BioImaging/biomero/actions/workflows/python-package.yml) [![python-publish build](https://github.com/NL-BioImaging/biomero/actions/workflows/python-publish.yml/badge.svg?branch=main)](https://github.com/NL-BioImaging/biomero/actions/workflows/python-publish.yml)

  The **BIOMERO** framework, for **B**io**I**mage analysis in **OMERO**, allows you to run (FAIR) bioimage analysis workflows directly from OMERO on a high-performance compute (HPC) cluster, remotely through SSH.

  The BIOMERO framework consists of this Python library `biomero`, together with the [BIOMERO scripts](https://github.com/NL-BioImaging/biomero-scripts) that can be run directly from the OMERO web interface.

  The package includes the `SlurmClient` class, which provides **SSH-based connectivity** and interaction with a [Slurm](https://slurm.schedmd.com/quickstart.html) (high-performance compute) cluster. The package enables users to submit jobs, monitor job status, retrieve job output, and perform other Slurm-related tasks. Additionally, the package offers functionality for configuring and managing paths to Slurm data and Singularity images (think Docker containers...), as well as specific FAIR image analysis workflows and their associated repositories.

  Overall, the `biomero` package simplifies the integration of HPC functionality within the OMERO platform for admins and provides an efficient and end-user-friendly interface towards both the HPC and FAIR workflows.

  _WARNING_: Please note that default settings are for short/medium jobs. If you run long workflows (>45min), you will run into 2 lethal issues:
  - Your Slurm job will timeout after **45 minutes**! See [Time Limit on Slurm](#time-limit-on-slurm) on what configs to change.
  - Your OMERO script (incl [biomero-scripts](https://github.com/NL-BioImaging/biomero-scripts)) will timeout after **60 minutes**! Change [omero script timeout](https://omero.readthedocs.io/en/stable/sysadmins/config.html#omero.scripts.timeout) settings if you expect longer workflows.



  In the figure below we show our **BIOMERO** framework, for **B**io**I**mage analysis in **OMERO**.

  BIOMERO consists of this Python library (`biomero`) and the integrations within OMERO, currently through our [BIOMERO scripts](https://github.com/NL-BioImaging/biomero-scripts).

  ![OMERO-Figure1_Overview_v5](https://github.com/NL-BioImaging/biomero/assets/68958516/ff437ed2-d4b7-48b4-a7e3-12f1dbf00981)







  For a quick overview of what this library can do for you, we can install an example setup locally with Docker:

  1. Setup a local OMERO w/ this library:
      - Follow Quickstart of https://github.com/Cellular-Imaging-Amsterdam-UMC/NL-BIOMERO
  2. Setup a local Slurm w/ SSH access:
      - Follow Quickstart of https://github.com/TorecLuik/slurm-docker-cluster
  3. Upload some data with OMERO.insight to `localhost` server (... we are working on a web importer ... TBC)
  4. Try out some scripts from https://github.com/NL-BioImaging/biomero-scripts (already installed in step 1!):
      1. Run script `slurm/init/SLURM Init environment...`
      2. Get a coffee or something. This will take at least 10 min to download all the workflow images. Maybe write a nice review on `image.sc` of this software, or here on the `Discussions` tab of Github.
      3. Select your image / dataset and run script `slurm/workflows/SLURM Run Workflow...`
          - Select at least one of the `Select how to import your results`, e.g. change `Import into NEW Dataset` text to `hello world`
          - Select a fun workflow, e.g. `cellpose`.
              - Change the `nuc channel` to the channel to segment (note that 0 is for grey, so 1,2,3 for RGB)
              - Uncheck the `use gpu` (step 2, our HPC cluster, doesn't come with GPU support built into the containers)
          - Refresh your OMERO `Explore` tab to see your `hello world` dataset with a mask image when the workflow is done!






  Note: This library has only been tested on Slurm versions 21.08.6 and 22.05.09 !

  Your Slurm cluster/login node needs to have:
  1. SSH access w/ public key (headless)
  2. SCP access (generally comes with SSH)
  3. 7zip installed
  4. Singularity/Apptainer installed
  5. (Optional) Git installed, if you want your own job scripts
  6. Slurm accounting enabled



  Your OMERO _processing_ node needs to have:
  1. SSH client and access to the Slurm cluster (w/ private key / headless)
  2. SCP access to the Slurm cluster
  3. Python3.7+
  4. This library installed
      - Latest release on PyPI `python3 -m pip install biomero`
      - or latest Github version `python3 -m pip install 'git+https://github.com/NL-BioImaging/biomero'`
  5. Configuration setup at `/etc/slurm-.ini`
  6. Requirements for some scripts: `python3 -m pip install ezomero==1.1.1 tifffile==2020.9.3` and the [OMERO CLI Zarr plugin](https://github.com/ome/omero-cli-zarr).

  Your OMERO _server_ node needs to have:
  1. Some OMERO example scripts installed to interact with this library:
      - My examples on github: `https://github.com/NL-BioImaging/biomero-scripts`
      - Install those at `/opt/omero/server/OMERO.server/lib/scripts/slurm/`, e.g. `git clone https://github.com/NL-BioImaging/biomero-scripts.git <path>/slurm`

  !!*NOTE*: Do not install [Example Minimal Slurm Script](https://github.com/NL-BioImaging/biomero-scripts/blob/master/Example_Minimal_Slurm_Script.py) if you do not trust your users with your Slurm cluster. It has literal Command Injection for the SSH user as a **FEATURE**.






  To connect an OMERO processor to a Slurm cluster using the `biomero` library, users can follow these steps:

  1. Setup passwordless public key authentication between your OMERO `processor` server and your HPC server. E.g. follow  a [SSH tutorial](https://www.ssh.com/academy/ssh/public-key-authentication) or [this one](https://linuxize.com/post/how-to-setup-passwordless-ssh-login/).
      - You could use 1 Slurm account for all `processor` servers, and share the same private key to all of them.
      - Or you could use unique accounts, but give them all the same alias in step 2.

  2. Create a SSH config file named `config` in the `.ssh` directory of (all) the OMERO `processor` servers, within the `omero` user's home directory (`~/.ssh/config`). This file should specify the hostname, username, port, and private key path for the Slurm cluster, under some alias. This alias we will provide to the library. We provide an example in the [resources](./resources/config) directory.

      - This will allow a uniform SSH naming, and makes the connection headless; making it easy for the library.

      - Test the SSH connection manually! `ssh slurm` (as the omero user) should connect you to the Slurm server (given that you named it `slurm` in the `config`).

      - Congratulations! Now the servers are connected. Next, we make sure to setup the connection between OMERO and Slurm.

  3. At this point, ensure that the `slurm-config.ini` file is correctly configured with the necessary SSH and Slurm settings, including the host, data path, images path, and model details. Customize the configuration according to the specific Slurm cluster setup. We provide an example in the [resources](./resources/slurm-config.ini) section. To read it automatically, place this `ini` file in one of the following locations (on the OMERO `processor` server):
      - `/etc/slurm-config.ini`
      - `~/slurm-config.ini`

      *Note*: Make sure to place the `slurm-config.ini` in the target folder at build time of your docker container instead of mounting it at runtime. This is because the library reads the config file at import time, and if it is not found, it will not work.

  4. Install OMERO scripts from [OMERO Slurm Scripts](https://github.com/NL-BioImaging/biomero-scripts), e.g.
      - `cd /opt/omero/server/OMERO.server/lib/scripts`
      - `git clone https://github.com/NL-BioImaging/biomero-scripts.git slurm`

  !!*NOTE*: Do not install [Example Minimal Slurm Script](https://github.com/NL-BioImaging/biomero-scripts/blob/master/Example_Minimal_Slurm_Script.py) if you do not trust your users with your Slurm cluster. It has literal Command Injection for the SSH user as a **FEATURE**.

  5. Install [BIOMERO Scripts](https://github.com/NL-BioImaging/biomero-scripts/) requirements, e.g.
      - `python3 -m pip install ezomero==1.1.1 tifffile==2020.9.3`
      - the [OMERO CLI Zarr plugin](https://github.com/ome/omero-cli-zarr), e.g.
      `python3 -m pip install omero-cli-zarr==0.5.3` && `yum install -y blosc-devel`
      - the [bioformats2raw-0.7.0](https://github.com/glencoesoftware/bioformats2raw/releases/download/v0.7.0/bioformats2raw-0.7.0.zip), e.g. `unzip -d /opt bioformats2raw-0.7.0.zip && export PATH="$PATH:/opt/bioformats2raw-0.7.0/bin"`

  6. To finish setting up your `SlurmClient` and Slurm server, run it once with `init_slurm=True`. This is provided in a OMERO script form at [init/Slurm Init environment](https://github.com/NL-BioImaging/biomero-scripts/blob/master/init/SLURM_Init_environment.py) , which you just installed in previous step.
      - Provide the configfile location explicitly if it is not a default one defined earlier, otherwise you can omit that field.
      - Please note the requirements for your Slurm cluster. We do not install Singularity / 7zip on your cluster for you (at the time of writing).
      - This operation will make it create the directories you provided in the `slurm-config.ini`, pull any described Singularity images to the server (note: might take a while), and generate (or clone from Git) any job scripts for these workflows:

  ```python
  with SlurmClient.from_config(configfile=configfile,
                              init_slurm=True) as slurmClient:
      slurmClient.validate(validate_slurm_setup=True)
  ```

  With the configuration files in place, you can utilize the `SlurmClient` class from the `biomero` library to connect to the Slurm cluster over SSH, enabling the submission and management of Slurm jobs from an OMERO processor.



  The easiest interaction from OMERO with this library currently is through our BIOMERO scripts, which are just a set of OMERO scripts using this library for all the steps one needs to run a image analysis workflow from OMERO on Slurm and retrieve the results back into OMERO.

  !!*NOTE*: Do not install [Example Minimal Slurm Script](https://github.com/NL-BioImaging/biomero-scripts/blob/master/Example_Minimal_Slurm_Script.py) if you do not trust your users with your Slurm cluster. It has literal Command Injection for the SSH user as a **FEATURE**.

  We have provided the BIOMERO scripts at https://github.com/NL-BioImaging/biomero-scripts (hopefully installed in a previous step).

  For example, [workflows/Slurm Run Workflow](https://github.com/NL-BioImaging/biomero-scripts/blob/master/workflows/SLURM_Run_Workflow.py) should provide an easy way to send data to Slurm, run the configured and chosen workflow, poll Slurm until jobs are done (or errors) and retrieve the results when the job is done. This workflow script uses some of the other scripts, like

  -  [`data/Slurm Image Transfer`](https://github.com/NL-BioImaging/biomero-scripts/blob/master/data/_SLURM_Image_Transfer.py): to export your selected images / dataset / screen as TIFF files to a Slurm dir.
  - [`data/Slurm Get Results`](https://github.com/NL-BioImaging/biomero-scripts/blob/master/data/SLURM_Get_Results.py): to import your Slurm job results back into OMERO as a zip, dataset or attachment.

  Other example OMERO scripts are:
  - [`data/Slurm Get Update`](https://github.com/NL-BioImaging/biomero-scripts/blob/master/data/SLURM_Get_Update.py): to run while you are waiting on a job to finish on Slurm; it will try to get a `%` progress from your job's logfile. Depends on your job/workflow logging a `%` of course.

  - [`workflows/Slurm Run Workflow Batched`](https://github.com/NL-BioImaging/biomero-scripts/blob/master/workflows/SLURM_Run_Workflow_Batched.py): This will allow you to run several `workflows/Slurm Run Workflow` in parallel, by batching your input images into smaller chunks (e.g. turn 64 images into 2 batches of 32 images each). It will then poll all these jobs.

  - [`workflows/Slurm CellPose Segmentation`](https://github.com/NL-BioImaging/biomero-scripts/blob/master/workflows/SLURM_CellPose_Segmentation.py): This is a more primitive script that only runs the actual workflow `CellPose` (if correctly configured). You will need to manually transfer data first (with `Slurm Image Transfer`) and manually retrieve data afterward (with `Slurm Get Results`).

  You are encouraged to create your own custom scripts. Do note the copy-left license enforced by OME.


  We host BIOMERO container dockerfiles at [NL-BIOMERO](https://github.com/Cellular-Imaging-Amsterdam-UMC/NL-BIOMERO), which publishes container images to our public dockerhub [cellularimagingcf](https://hub.docker.com/repositories/cellularimagingcf). Specifically the [cellularimagingcf/biomero](https://hub.docker.com/repository/docker/cellularimagingcf/biomero/general) image is an OMERO processor container with BIOMERO library installed. When we release a new version of BIOMERO, we will also release a new version of these containers (because we deploy these locally at our Core Facility - Cellular Imaging).

  You can mount your specific configurations over those in the container, for example:

  ```

  echo "Starting BIOMERO..."
  podman run -d --rm --name biomero \
    -e CONFIG_omero_master_host=omeroserver \
    -e OMERO_WORKER_NAME=biomero \
    -e CONFIG_omero_logging_level=10 \
    --network omero \
    --volume /mnt/datadisk/omero:/OMERO \
    --volume /mnt/data:/data \
    --volume /my/slurm-config.ini:/etc/slurm-config.ini \
    --secret ssh-config,target=/tmp/.ssh/config --secret ssh-key,target=/tmp/.ssh/id_rsa --secret ssh-pubkey,target=/tmp/.ssh/id_rsa.pub  --secret ssh-known_hosts,target=/tmp/.ssh/known_hosts \
    --userns=keep-id:uid=1000,gid=997 \
    cellularimagingcf/biomero:0.2.3
  ```

  This will spin up the docker container (in Podman) with omero config (`-e CONFIG_omero_..`), mounting the required data drives (`--volume /mnt/...`) and adding a new slurm config (`--volume /my/slurm-config.ini:/etc/slurm-config.ini`) and the required SSH settings (`--secret ...,target=/tmp/.ssh/...`) to access the remote HPC.

  Note: the [BIOMERO scripts](https://github.com/NL-BioImaging/biomero-scripts) are installed on the [main server](https://hub.docker.com/repository/docker/cellularimagingcf/omeroserver/general), not on the BIOMERO processor.

  Note2: We will also update these containers with our own desired changes, so they will likely not be 1:1 copy with basic omero containers. Especially when we start making a nicer UI for BIOMERO. We will keep up-to-date with the OMERO releases when possible.


  I have also provided tutorials on connecting to a Local or Cloud Slurm, and tutorials on how to add your FAIR workflows to this setup. Those can give some more insights as well.


  Note: this library is built for **SSH-based connections**. If you could, it would be a lot easier to just have the OMERO `processor` server and the `slurm` client server be (on) the same machine: then you can just directly call `sbatch` and other `slurm` commands from OMERO scripts and Slurm would have better access to your data.

  This is mainly for those cases where you already have an external HPC cluster and want to connect your OMERO instance.

  Theoretically, you could extend the `SlurmClient` class and change the `run` commands to not use SSH, but just a `subprocess`. We might implement this if we need it in the future.
  But then you could also look at other Python libraries like [submitit](https://github.com/facebookincubator/submitit).


  The SlurmClient class is the main entrypoint in using this library.
  It is a Python class that extends the Connection class from the Fabric library. It allows connecting to and interacting with a Slurm cluster over SSH.

  It includes attributes for specifying paths to directories for Slurm data and Singularity images, as well as specific paths, repositories, and Dockerhub information for different Singularity image models.

  The class provides methods for running commands on the remote Slurm host, submitting jobs, checking job status, retrieving job output, and tailing log files.

  It also offers a `from_config` class method to create a `SlurmClient` object by reading configuration parameters from a file. Overall, the class provides a convenient way to work with Slurm clusters and manage job execution and monitoring.



  The `slurm-config.ini` file is a configuration file used by the `biomero` Python package to specify various settings related to SSH and Slurm. Here is a brief description of its contents:

  [**SSH**]: This section contains SSH settings, including the alias for the SLURM SSH connection (host). Additional SSH configuration can be specified in the user's SSH config file or in `/etc/fabric.yml`.

  [**SLURM**]: This section includes settings specific to Slurm. It defines the paths on the SLURM entrypoint for storing data files (slurm_data_path), container image files (slurm_images_path), and Slurm job scripts (slurm_script_path). It also specifies the repository (slurm_script_repo) from which to pull the Slurm scripts.

  [**MODELS**]: This section is used to define different model settings. Each model has a unique key and requires corresponding values for `<key>_repo` (repository containing the descriptor.json file, which will describe parameters and where to find the image), and `<key>_job` (jobscript name and location in the `slurm_script_repo`). The example shows settings for several segmentation models, including Cellpose, Stardist, CellProfiler, DeepCell, and ImageJ.

  Note also that you can override the default Slurm job values using this model configuration, like memory, GPU, time limit, etc.
  All values for sbatch can be applied (see e.g. [here](https://slurm.schedmd.com/sbatch.html)) and will be forwarded to the job command.

  For example
  ```

  cellpose_job_gres=gpu:1g.10gb:1

  cellpose_job_mem=15GB
  ```

  The `slurm-config.ini` file allows users to configure paths, repositories, and other settings specific to their Slurm cluster and the `biomero` package, providing flexibility and customization options.


  An important Slurm job config is the time limit: `SBATCH --time=00:45:00` is the default in BIOMERO (max 45 minutes per job).
  The format is `d-hh:mm:ss`

  WARNING: After this time, the job will timeout and this scenario is not handled by BIOMERO (yet)! You will lose your processing progress.

  You can change this timeout value:

  - For ALL workflows, in the [job_template.sh](./resources/job_template.sh) (e.g. `#SBATCH --time=08:00:00` for 8 hours)
  - For ONE workflow, in the [slurm-config.ini](./resources/slurm-config.ini) (e.g. `cellpose_job_time=08:00:00` for 8 hours)
  - Per specific run, provide it in the OMERO script UI like [SLURM_CellPose_Segmentation.py](https://github.com/NL-BioImaging/biomero-scripts/blob/master/workflows/SLURM_CellPose_Segmentation.py)

  Note that it might take longer for Slurm to schedule your job if you put the time very high, or possibly even make it wait indefinitely (see --time explanation in https://slurm.schedmd.com/sbatch.html). We will work on smart timing, but for now it is hardcoded and configurable.




  To add an existing (containerized) workflow, add it to the `slurm-config.ini` file like in our example:
  ```ini




  cellpose=cellpose

  cellpose_repo=https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/tree/v1.2.7

  cellpose_job=jobs/cellpose.sh
  ```
  Here,
  1. the name referenced for this workflow is `cellpose`
  2. the location of the container on slurm will be `<slurm_images_path>/cellpose`
  3. the code repository is `https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose`
  4. the specific version we want is `v1.2.7`
  5. the container can be found on bitbucket
      - under the path given in the metadata file: [descriptor.json](https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/blob/v1.2.7/descriptor.json)
  5. the location of the jobscript on slurm will be `<slurm_script_repo>/jobs/cellpose.sh`.
      - This either references a git repo, where it matches this path,
      - or it will be the location where the library will generate a jobscript (if no repo is given)


  A lot of the automation in this library is based on metadata of the workflow, provided in the source code of the workflow, specifically the [descriptor.json](https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/blob/v1.2.7/descriptor.json).

  For example, the OMERO script UI can be generated automatically, based on this descriptor. And also, the Slurm job script can be generated automatically, based on this descriptor.

  This metadata scheme is (based on) Cytomine / BIAFLOWS, and you can find details of it and how to create one yourself on their website, e.g. this [Cytomine dev-guide](https://doc.uliege.cytomine.org/dev-guide/algorithms/write-app#create-the-json-descriptor) or this [BIAFLOWS dev-guide](https://neubias-wg5.github.io/developer_guide_add_new_workflow_to_biaflows_instance.html).

  **NOTE!** We do not require the `cytomine_<...>` authentication parameters. They are not mandatory. In fact, we ignore them. But it might be beneficial to make your workflow compatible with Cytomine as well.


  At this point, we are using the `cytomine-0.1` [schema](https://doc.uliege.cytomine.org/dev-guide/algorithms/descriptor-reference), in the future we will also want to support other schemas, like [Boutiques](https://boutiques.github.io/), [commonwl](https://www.commonwl.org/) or [MLFlow](https://www.mlflow.org/docs/latest/projects.html).

  We will try to stay compatible with all such schemas (perhaps with less functionality because of missing metadata).

  At this point, we do not strictly validate the schema, we just read expected fields from the `descriptor.json`.


  Note that while it is possible to have multiple versions of the same workflow on Slurm (and select the desired one in OMERO), it is not possible to configure this yet. We assume for now you only want one version to start with. You can always update this config to download a new version to Slurm.


  Unless you change the `Slurm` job, the input is expected to be:
  - The `infolder` parameter
      - pointing to a folder with multiple input files/images
  - The `gtfolder` parameter (Optional)
      - pointing to a `ground-truth` input files, generally not needed for prediction / processing purposes.
  - The `outfolder` parameter
      - where you write all your output files (to get copied back to OMERO)


  Note that you can also use the [wrapper.py](https://github.com/Neubias-WG5/W_Template/blob/master/wrapper.py) setup from BIAFLOWS to handle the I/O for you:

  ```python
  with BiaflowsJob.from_cli(argv) as bj:
          
          ...

          
          in_imgs, gt_imgs, in_path, gt_path, out_path, tmp_path = prepare_data(problem_cls, bj, is_2d=True, **bj.flags)

          
          bj.job.update(progress=25, statusComment="Launching workflow...")

          

          
          ...

          
          ...

          
          ...
  ```

  This wrapper handles the input parameters for you, providing the input images as `in_imgs`, et cetera. Then you add your commandline call between point 2 and 3, and possibly some preprocessing between point 1 and 2:
  ```python

  ```

  For example, from [Cellpose](https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/blob/master/wrapper.py) container workflow:
  ```python
  ...


  bj.job.update(progress=25, statusComment="Launching workflow...")


  prob_thresh = bj.parameters.prob_threshold
  diameter = bj.parameters.diameter
  cp_model = bj.parameters.cp_model
  use_gpu = bj.parameters.use_gpu
  print(f"Chosen model: {cp_model} | Channel {nuc_channel} | Diameter {diameter} | Cell prob threshold {prob_thresh} | GPU {use_gpu}")
  cmd = ["python", "-m", "cellpose", "--dir", tmp_path, "--pretrained_model", f"{cp_model}", "--save_tif", "--no_npy", "--chan", "{:d}".format(nuc_channel), "--diameter", "{:f}".format(diameter), "--cellprob_threshold", "{:f}".format(prob_thresh)]
  if use_gpu:
      print("Using GPU!")
      cmd.append("--use_gpu")
  status = subprocess.run(cmd)

  if status.returncode != 0:
      print("Running Cellpose failed, terminate")
      sys.exit(1)


  for bimg in in_imgs:
      shape = resized.get(bimg.filename, None)
      if shape:
          img = imageio.imread(os.path.join(tmp_path,bimg.filename_no_extension+"_cp_masks.tif"))
          img = img[0:shape[0], 0:shape[1]]
          imageio.imwrite(os.path.join(out_path,bimg.filename), img)
      else:
          shutil.copy(os.path.join(tmp_path,bimg.filename_no_extension+"_cp_masks.tif"), os.path.join(out_path,bimg.filename))


  ```
  We get the commandline parameters from `bj.parameters` (biaflows job) and provide that the `cmd` commandline string. Then we run it with `subprocess.run(cmd)` and check the `status`.

  We use a `tmp_path` to store both input and output, then move the output to the `out_path` after the processing is done.

  Also note that some preprocessing is done in step 1:
  ```python




  nuc_channel = bj.parameters.nuc_channel
  resized = {}
  for bfimg in in_imgs:
      ...
      imageio.imwrite(os.path.join(tmp_path, bfimg.filename), img)
  ```

  Another example is this `imageJ` [wrapper](https://github.com/Neubias-WG5/W_NucleiSegmentation3D-ImageJ/blob/master/wrapper.py):
  ```python
  ...


  nj.job.update(progress=25, statusComment="Launching workflow...")

  command = "/usr/bin/xvfb-run java -Xmx6000m -cp /fiji/jars/ij.jar ij.ImageJ --headless --console " \
              "-macro macro.ijm \"input={}, output={}, radius={}, min_threshold={}\"".format(in_path, out_path, nj.parameters.ij_radius, nj.parameters.ij_min_threshold)
  return_code = call(command, shell=True, cwd="/fiji")  # waits for the subprocess to return

  if return_code != 0:
      err_desc = "Failed to execute the ImageJ macro (return code: {})".format(return_code)
      nj.job.update(progress=50, statusComment=err_desc)
      raise ValueError(err_desc)

  ```
  Once again, just a commandline `--headless` call to `ImageJ`, wrapped in this Python script and this container.



  Building workflows like this will make them more [FAIR](https://www.go-fair.org/fair-principles/) (also for [software](https://fair-software.eu/about)) and uses best practices like code versioning and containerization!

  Also take a look at our in-depth tutorial on adding a Cellprofiler pipeline as a workflow to BIOMERO.

  Here is a shorter version:
  Say you have a script in Python and you want to make it available on OMERO and Slurm.

  These are the steps required:

  1. Rewrite your script to be headless / to be executable on the commandline. This requires handling of commandline parameters as input.
      - Make sure the I/O matches the Slurm job, see [previous chapter](#io).
  2. Describe these commandline parameters in a `descriptor.json` (see previous [chapter](#workflow-metadata-via-descriptorjson)). E.g. [like this](https://doc.uliege.cytomine.org/dev-guide/algorithms/write-app#create-the-json-descriptor).
  3. Describe the requirements / environment of your script in a `requirements.txt`, [like this](https://learnpython.com/blog/python-requirements-file/). Make sure to pin your versions for future reproducability!
  2. Package your script in a Docker container. E.g. [like this](https://www.docker.com/blog/how-to-dockerize-your-python-applications/).
      - Note: Please watch out for the pitfalls of reproducability with Dockerfiles: [Always version your packages!](https://pythonspeed.com/articles/dockerizing-python-is-hard/).
  3. Publish your source code, Dockerfile and descriptor.json to a new Github repository (free for public repositories). You can generate a new repository [from template](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-repository-from-a-template), using [this template](https://github.com/Neubias-WG5/W_Template) provided by Neubias (BIAFLOWS). Then replace the input of the files with yours.
  4. (Recommended) Publish a new version of your code (e.g. v1.0.0). E.g. [like this](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository).
  5. Publish your container on Dockerhub (free for public repositories), using the same versioning as your source code. [Like this](https://docs.docker.com/get-started/publish-your-own-image/) from Windows Docker or [like this](https://www.geeksforgeeks.org/docker-publishing-images-to-docker-hub/) from a commandline.
      - (Recommended) Please use a tag that equals your repository version, instead of `latest`. This improves reproducability!
      - (Optional) this library grabs `latest` if the code repository is given no version, but the `master` branch.
  6. Follow the steps from the previous [chapter](#how-to-add-an-existing-workflow):
      - Add details to `slurm-config.ini`
      - Run `SlurmClient.from_config(init_slurm=True)` (e.g. the init environment script.)




  By default, `biomero` will generate basic slurm jobs for each workflow, based on the metadata provided in `descriptor.json` and a [job template](./resources/job_template.sh).
  It will replace `$PARAMS` with the (non-`cytomine_`) parameters given in `descriptor.json`. See also the [Parameters](#parameters) section below.


  You could change the [job template](./resources/job_template.sh) and generate new jobs, by running `SlurmClient.from_config(init_slurm=True)` (or `slurmClient.update_slurm_scripts(generate_jobs=True)`)

  Or you could add your jobs to a [Github repository](https://github.com/TorecLuik/slurm-scripts) and reference this in `slurm-config.ini`, both in the field `slurm_script_repo` and every `<workflow>_job`:

  ```ini









  slurm_script_repo=https://github.com/TorecLuik/slurm-scripts

  [MODELS]








  cellpose=cellpose

  cellpose_repo=https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/tree/v1.2.7

  cellpose_job=jobs/cellpose.sh
  ```

  You can update the jobs by calling `slurmClient.update_slurm_scripts()`, which will pull the repository('s default branch).

  This might be useful, for example if you have other hardware requirements for your workflow(s) than the default job asks for, or if you want to run more than just 1 singularity container.


  The library will provide the parameters from your `descriptor.json` as environment variables to the call. E.g. `set DIAMETER=0; sbatch ...`.

  Other environment variables provided are:
  - `DATA_PATH`
      - Made of `<slurm_data_path>/<input_folder>`. The base dir for data folders for this execution. We expect it to contain `/data/in`, `/data/in` and `/data/in` folders in our template and data transfer setup.
  - `IMAGE_PATH`
      - Made of `<slurm_images_path>/<model_path>`, as described in `slurm-config.ini`
  - `IMAGE_VERSION`
  - `SINGULARITY_IMAGE`
      - Already uses the `IMAGE_VERSION` above, as `<container_name>_<IMAGE_VERSION>.sif`

  We (potentially) override the following Slurm job settings programmatically:
  - `--mail-user={email}` (optional)
  - `--time={time}` (optional)
  - `--output=omero-%4j.log` (mandatory)

  We could add more overrides in the future, and perhaps make them available as global configuration variables in `slurm-config.ini`.

  We can simply use `Slurm` for running your workflow 1:1, so 1 job to 1 workflow. This could speed up your workflow already, as `Slurm` servers are likely equipped with strong CPU and GPU.

  However, `Slurm` is also built for parallel processing on multiple (or the same) servers. We can accomplish this by running multiple jobs for 1 workflow. This is simple for [embarrassingly parallel](https://en.wikipedia.org/wiki/Embarrassingly_parallel#:~:text=In%20parallel%20computing%2C%20an%20embarrassingly,a%20number%20of%20parallel%20tasks.) tasks, like segmenting multiple images: just provide each job with a different set of input images. If you have 100 images, you could run 10 jobs on 10 images and (given enough resources available for you on Slurm) that could be 10x faster. In theory, you could run 1 job per image, but at some point you run into the overhead cost of Slurm (and OMERO) and it might actually slow down again (as you incur this cost a 100 times instead of 10 times).



  Note, the [default](./resources/job_template.sh) Slurm job script will not request any GPU resources.

  This is because GPU resources are expensive and some programs do not work with GPU.

  We can instead _enable_ the use of GPU by either providing our own Slurm job scripts, or setting an override value in `slurm-config.ini`:

  ```ini




  cellpose=cellpose

  cellpose_repo=https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/tree/v1.2.7

  cellpose_job=jobs/cellpose.sh




  cellpose_job_gres=gpu:1g.10gb:1
  ```

  In fact, any `..._job_...=...` configuration value will be forwarded to the Slurm commandline.

  Slurm commandline parameters override those in the script, so the above one requests 1 10GB gpu for Cellpose.

  E.g. you could also set the time limit higher:

  ```ini




  cellpose=cellpose

  cellpose_repo=https://github.com/TorecLuik/W_NucleiSegmentation-Cellpose/tree/v1.2.7

  cellpose_job=jobs/cellpose.sh




  cellpose_job_time=00:30:00
  ```

  Now the CellPose job should run for maximum of 30 minutes, instead of the default.



  We have added methods to this library to help with transferring data to the `Slurm` cluster, using the same SSH connection (via SCP or SFTP).

  - `slurmClient.transfer_data(...)`
      - Transfer data to the Slurm cluster
  - `slurmClient.unpack_data(...)`
      - Unpack zip file on the Slurm cluster
  - `slurmClient.zip_data_on_slurm_server(...)`
      - Zip data on the Slurm cluster
  - `slurmClient.copy_zip_locally(...)`
      - Transfer (zip) data from the Slurm cluster
  - `slurmClient.get_logfile_from_slurm(...)`
      - Transfer logfile from the Slurm cluster

  And more; see the docstring of `SlurmClient` and example OMERO scripts.


  You can test the library by installing the extra test dependencies:

  1. Create a venv to isolate the python install:
  `python -m venv venvTest`

  2. Install OSC with test dependencies:
  `venvTest/Scripts/python -m pip install .[test]`

  3. Run pytest from this venv:
  `venvTest/Scripts/pytest`


  Debug logging can be enabled with the standard python logging module, for example with logging.basicConfig():

  ```
  import logging

  logging.basicConfig(level='DEBUG')
  ```

  For example in (the `__init__` of) a script:

  ```Python
  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO,
                          format='s - s - s - s',
                          stream=sys.stdout)
      runScript()
  ```

rpm_license:
[cell repeats an earlier one in this file: 10254 characters]


pkgId: 6e112d24dd98b4b3199e1c9ab31b13b0ee2eb81d98630fc09f1ba4c97a5d635c
name: python-biomodels-restful-api-client
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: BioModels RESTful API - Web Services
url: https://github.com/EBI-BioModels/biomodels-resftful-api-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biomodels-restful-api-client-0.1.3-1.src.rpm
checksum_type: sha256
description:
  This package implements the **RESTful** API exposed in BioModels repository. All API endpoints can be followed up at
  [BioModels' RESTful Web Services](https://www.ebi.ac.uk/biomodels/docs/).



  ```bash
  pip install biomodels-restful-api-client
  ```





  ```python
  >>> from biomodels_restful_api_client import services as bmservices
  >>> bmservices.get_model_info("BIOMD0000000900")
  {'name': 'Bianca2013 - Persistence analysis in a Kolmogorov-type model for cancer-immune system competition',...,
  'submissionId': 'MODEL1912180002', 'publicationId': 'BIOMD0000000900'}
  ```



  ```python
  >>> bmservices.get_model_identifiers()
  {'hits': 2874, 'models': ['BIOMD0000000001', 'BIOMD0000000002', 'BIOMD0000000003', 'BIOMD0000000004', ...,
  'MODEL9808533471', 'MODEL9810152478', 'MODEL9811206584']}
  ```



  * [Tung Nguyen](https://github.com/ntung)



  * [BioModels Developers](mailto:biomodels-developers@ebi.ac.uk)



  Please read [LICENSE](LICENSE) for information on the software availability and distribution.


pkgId: 28243418d06c47f319e6ade8cc76d17f1cf91064bce6f63dbe748dff5aed691b
name: python-bionic
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: A Python framework for building, running, and sharing data science workflows
url: https://github.com/square/bionic
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bionic-0.11.1-1.src.rpm
checksum_type: sha256
description:
  Bionic is a framework for analyzing and modeling data in Python.  It's designed
  to help you **iterate faster on your research**, and help your colleagues
  **reuse your code more easily**.

  Bionic is in alpha and evolving rapidly.  We recommend it for research projects
  where the dataset fits in memory.  We do not recommend it for pipelines running
  in production.

  Check out the [full documentation](https://bionic.readthedocs.io/en/stable/),
  or go straight to [Get
  Started](https://bionic.readthedocs.io/en/stable/get-started.html).



  Bionic can be installed from PyPI:

      pip install bionic[standard]

  You'll probably want to install [Graphviz](https://www.graphviz.org/) as well.
  See the [Installation
  docs](https://bionic.readthedocs.io/en/stable/get-started.html#installation)
  for more details on installing and configuring Bionic's dependencies.



  See the
  [Contribution](https://bionic.readthedocs.io/en/stable/contributing.html)
  section of our docs.



  Copyright 2019 Square, Inc.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.


pkgId: bcdbec75a11a668e558141eec2c263678bb8a3a81d73426cc6063d65c9d72fe9
name: python-bionty
arch: src
version: 0.51.2
epoch: 0
release: 1
summary: Registries for basic biological entities, coupled to public ontologies.
url: https://pypi.org/project/bionty/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bionty-0.51.2-1.src.rpm
checksum_type: sha256
description:
  [![Stars](https://img.shields.io/github/stars/laminlabs/bionty?logo=GitHub&color=yellow)](https://github.com/laminlabs/bionty)
  [![pypi](https://img.shields.io/pypi/v/bionty?color=blue&label=pypi%20package)](https://pypi.org/project/bionty)



  - Access >20 public ontologies such as Gene, Protein, CellMarker, ExperimentalFactor, CellType, CellLine, Tissue, …
  - Create records from entries in public ontologies using `.from_source()`.
  - Access full underlying public ontologies via `.public()` to search & bulk-create records.
  - Create in-house ontologies by extending public ontologies using hierarchical relationships among records (`.parents`).
  - Use `.synonyms` and `.abbr` to manage synonyms.
  - Safeguards against typos & duplications
  - Ontology versioning

  Read [docs](https://docs.lamin.ai/bionty).


pkgId: dd63ab169aff4fa787a5645422d639e83e88d8abcda5504ab40241addc1d96be
name: python-bionty
arch: src
version: 0.52.0
epoch: 0
release: 1
url: https://pypi.org/project/bionty/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bionty-0.52.0-1.src.rpm
checksum_type: sha256
summary:
  Basic biological entities, coupled to public ontologies [`source <https://github.com/laminlabs/bionty/blob/main/bionty/models.py>`__].

description:
  [![Stars](https://img.shields.io/github/stars/laminlabs/bionty?logo=GitHub&color=yellow)](https://github.com/laminlabs/bionty)
  [![pypi](https://img.shields.io/pypi/v/bionty?color=blue&label=pypi%20package)](https://pypi.org/project/bionty)



  - Access >20 public ontologies such as Gene, Protein, CellMarker, ExperimentalFactor, CellType, CellLine, Tissue, …
  - Create records from entries in public ontologies using `.from_source()`.
  - Access full underlying public ontologies via `.public()` to search & bulk-create records.
  - Create in-house ontologies by extending public ontologies using hierarchical relationships among records (`.parents`).
  - Use `.synonyms` and `.abbr` to manage synonyms.
  - Safeguards against typos & duplications
  - Ontology versioning

  Read [docs](https://docs.lamin.ai/bionty).


pkgId: bb29e37d53c57fc2ddbac92a89ed64c4c21bb913d63e05a93f49120b098c6587
name: python-bioomics
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: Download, retrieve and process omics data for further bioinformatics
url: https://github.com/Tiezhengyuan/bio_omics
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioomics-0.2.9-1.src.rpm
checksum_type: sha256
description:
  \n# bio_omics
  Download, retrieve and process omics data, or biological informatics data from public database

  Comprehensive Databases
  - NCBI: genome database,
  - UniProt: protein database, https://www.expasy.org/resources/uniprotkb-swiss-prot

  Sepecific Databases
  - miRBase: mircoRNA database, https://www.mirbase.org/
  - RNACentral: non-coding RNA squence database, https://rnacentral.org/
  - IEDB: immune epitope database, https://www.iedb.org/


  See the help documents of example coding at https://www.fbridges.com/pipeline/bio_omics.

  https://www.iedb.org/downloader.php?file_name=doc/epitope_full_v3.zip



  ETL data processing is composed of some steps including downloads, retrieval, organization, combination, integration, enrichment, formation. This packages focus on downloads, retrieval, and combination of omics data.
  It is suggested that the data model would be consistent. Data are organized by entity namely protein, or antigen. An example of data is showed as the below. Here the pair 'key' defines unique identifier of this entity. "ID" is automatically created. Retrieved data are pushed as one key-value.
  Note:
  - Abundant data are possible and to be allowed.
  - The key-value is defined by this corresponding database source.
  - Used for Integration rather than enrichment. Therefore, data combination or aggregation is not recommended.
  - Data from various source could be different or invalid. Those would be validated in the afterwards step rather than this step.
  ```
  {
      "ID": "79541",
      "key": "H0YED9",
      "UniProt_SwissProt": {
          ....
      },
      "NCBI": {
          ....
      },
      "PDB": {
          ....
      },
      ....
  }
  ```


pkgId: a2303d18acc1b7ea3baf763c10ce1fff3c4e6700a9860213e7be5395de61598b
name: python-bioontologies
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Tools for biomedical ontologies
url: https://github.com/biopragmatics/bioontologies
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioontologies-0.5.2-1.src.rpm
checksum_type: sha256
description:
  <!--
  <p align="center">
    <img src="https://github.com/biopragmatics/bioontologies/raw/main/docs/source/logo.png" height="150">
  </p>
  -->

  <h1 align="center">
    Bioontologies
  </h1>

  <p align="center">
      <a href="https://github.com/biopragmatics/bioontologies/actions/workflows/tests.yml">
          <img alt="Tests" src="https://github.com/biopragmatics/bioontologies/actions/workflows/tests.yml/badge.svg" /></a>
      <a href="https://pypi.org/project/bioontologies">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/bioontologies" /></a>
      <a href="https://pypi.org/project/bioontologies">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/bioontologies" /></a>
      <a href="https://github.com/biopragmatics/bioontologies/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/bioontologies" /></a>
      <a href='https://bioontologies.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/bioontologies/badge/?version=latest' alt='Documentation Status' /></a>
      <a href="https://codecov.io/gh/biopragmatics/bioontologies/branch/main">
          <img src="https://codecov.io/gh/biopragmatics/bioontologies/branch/main/graph/badge.svg" alt="Codecov status" /></a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-snekpack-blue" /></a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;"></a>
      <a href="https://github.com/biopragmatics/bioontologies/blob/main/.github/CODE_OF_CONDUCT.md">
          <img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"/></a>
      <!-- uncomment if you archive on zenodo
      <a href="https://zenodo.org/badge/latestdoi/XXXXXX">
          <img src="https://zenodo.org/badge/XXXXXX.svg" alt="DOI"></a>
      -->
  </p>

  Tools for biomedical ontologies



  This package lets you get OBO Graphs from ontologies based on their OWL
  files, OBO files, or [Bioregistry](https://bioregistry.io) prefixes. Internally,
  it uses [ROBOT](https://robot.obolibrary.org) to convert from these formats
  to [OBO Graph JSON](https://github.com/geneontology/obographs).

  ```python
  import bioontologies


  owl_iri = "http://purl.obolibrary.org/obo/go.owl"
  parse_results = bioontologies.convert_to_obograph(owl_iri)


  obo_iri = "http://purl.obolibrary.org/obo/go.obo"
  parse_results = bioontologies.convert_to_obograph(obo_iri)


  parse_results = bioontologies.get_obograph_by_prefix("go")
  go_graph_document = parse_results.graph_document
  ```



  The most recent release can be installed from
  [PyPI](https://pypi.org/project/bioontologies/) with:

  ```console
  python3 -m pip install bioontologies
  ```

  The most recent code and data can be installed directly from GitHub with:

  ```console
  python3 -m pip install git+https://github.com/biopragmatics/bioontologies.git
  ```



  Contributions, whether filing an issue, making a pull request, or forking, are appreciated. See
  [CONTRIBUTING.md](https://github.com/biopragmatics/bioontologies/blob/master/.github/CONTRIBUTING.md)
  for more information on getting involved.





  The code in this package is licensed under the MIT License.

  <!--


  Citation goes here!
  -->



  The Bioregistry was initially developed by the [INDRA Lab](https://indralab.github.io), a part of the
  [Laboratory of Systems Pharmacology](https://hits.harvard.edu/the-program/laboratory-of-systems-pharmacology/about/)
  and the [Harvard Program in Therapeutic Science (HiTS)](https://hits.harvard.edu)
  at [Harvard Medical School](https://hms.harvard.edu/).



  The development of this package was partially funded by the DARPA Young Faculty Award W911NF2010255 (PI: Benjamin M. Gyori).



  This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s
  [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s
  [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template.



  <details>
    <summary>See developer instructions</summary>

  The final section of the README is for if you want to get involved by making a code contribution.



  To install in development mode, use the following:

  ```console
  git clone git+https://github.com/biopragmatics/bioontologies.git
  cd bioontologies
  python3 -m pip install -e .
  ```



  This project uses `cruft` to keep boilerplate (i.e., configuration, contribution guidelines, documentation
  configuration)
  up-to-date with the upstream cookiecutter package. Update with the following:

  ```console
  python3 -m pip install cruft
  cruft update
  ```

  More info on Cruft's update command is
  available [here](https://github.com/cruft/cruft?tab=readme-ov-file#updating-a-project).



  After cloning the repository and installing `tox` with
  `python3 -m pip install tox tox-uv`,
  the unit tests in the `tests/` folder can be run reproducibly with:

  ```console
  tox -e py
  ```

  Additionally, these tests are automatically re-run with each commit in a
  [GitHub Action](https://github.com/biopragmatics/bioontologies/actions?query=workflow%3ATests).



  The documentation can be built locally using the following:

  ```console
  git clone git+https://github.com/biopragmatics/bioontologies.git
  cd bioontologies
  tox -e docs
  open docs/build/html/index.html
  ```

  The documentation automatically installs the package as well as the `docs`
  extra specified in the [`pyproject.toml`](pyproject.toml). `sphinx` plugins
  like `texext` can be added there. Additionally, they need to be added to the
  `extensions` list in [`docs/source/conf.py`](docs/source/conf.py).

  The documentation can be deployed to [ReadTheDocs](https://readthedocs.io) using
  [this guide](https://docs.readthedocs.io/en/stable/intro/import-guide.html).
  The [`.readthedocs.yml`](.readthedocs.yml) YAML file contains all the configuration you'll need.
  You can also set up continuous integration on GitHub to check not only that
  Sphinx can build the documentation in an isolated environment (i.e., with `tox -e docs-test`)
  but also that [ReadTheDocs can build it too](https://docs.readthedocs.io/en/stable/pull-requests.html).



  1. Log in to ReadTheDocs with your GitHub account to install the integration
     at https://readthedocs.org/accounts/login/?next=/dashboard/
  2. Import your project by navigating to https://readthedocs.org/dashboard/import then clicking the plus icon next to
     your repository
  3. You can rename the repository on the next screen using a more stylized name (i.e., with spaces and capital letters)
  4. Click next, and you're good to go!





  [Zenodo](https://zenodo.org) is a long-term archival system that assigns a DOI to each release of your package.

  1. Log in to Zenodo via GitHub with this link: https://zenodo.org/oauth/login/github/?next=%2F. This brings you to a
     page that lists all of your organizations and asks you to approve installing the Zenodo app on GitHub. Click "grant"
     next to any organizations you want to enable the integration for, then click the big green "approve" button. This
     step only needs to be done once.
  2. Navigate to https://zenodo.org/account/settings/github/, which lists all of your GitHub repositories (both in your
     username and any organizations you enabled). Click the on/off toggle for any relevant repositories. When you make
     a new repository, you'll have to come back to this

  After these steps, you're ready to go! After you make "release" on GitHub (steps for this are below), you can navigate
  to https://zenodo.org/account/settings/github/repository/biopragmatics/bioontologies
  to see the DOI for the release and link to the Zenodo record for it.



  You only have to do the following steps once.

  1. Register for an account on the [Python Package Index (PyPI)](https://pypi.org/account/register)
  2. Navigate to https://pypi.org/manage/account and make sure you have verified your email address. A verification email
     might not have been sent by default, so you might have to click the "options" dropdown next to your address to get to
     the "re-send verification email" button
  3. 2-Factor authentication is required for PyPI since the end of 2023 (see
     this [blog post from PyPI](https://blog.pypi.org/posts/2023-05-25-securing-pypi-with-2fa/)). This means
     you have to first issue account recovery codes, then set up 2-factor authentication
  4. Issue an API token from https://pypi.org/manage/account/token



  You have to do the following steps once per machine. Create a file in your home directory called
  `.pypirc` and include the following:

  ```ini
  [distutils]
  index-servers =
      pypi
      testpypi

  [pypi]
  username = __token__
  password = <the API token you just got>


  [testpypi]
  repository = https://test.pypi.org/legacy/
  username = __token__
  password = <an API token from test PyPI>
  ```

  Note that since PyPI is requiring token-based authentication, we use `__token__` as the user, verbatim.
  If you already have a `.pypirc` file with a `[distutils]` section, just make sure that there is an `index-servers`
  key and that `pypi` is in its associated list. More information on configuring the `.pypirc` file can
  be found [here](https://packaging.python.org/en/latest/specifications/pypirc).



  After installing the package in development mode and installing
  `tox` with `python3 -m pip install tox tox-uv`,
  run the following from the console:

  ```console
  tox -e finish
  ```

  This script does the following:

  1. Uses [bump-my-version](https://github.com/callowayproject/bump-my-version) to switch the version number in
     the `pyproject.toml`, `CITATION.cff`, `src/bioontologies/version.py`,
     and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel using
     [`uv build`](https://docs.astral.sh/uv/guides/publish/#building-your-package)
  3. Uploads to PyPI using [`twine upload`](https://github.com/pypa/twine).
     This will be replaced soon with `uv publish` (see https://github.com/cthoyt/cookiecutter-snekpack/issues/29)
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion -- minor` after.



  1. Navigate
     to https://github.com/biopragmatics/bioontologies/releases/new
     to draft a new release
  2. Click the "Choose a Tag" dropdown and select the tag corresponding to the release you just made
  3. Click the "Generate Release Notes" button to get a quick outline of recent changes. Modify the title and description
     as you see fit
  4. Click the big green "Publish Release" button

  This will trigger Zenodo to assign a DOI to your release as well.

  </details>

rpm_license:
  MIT License  Copyright (c) 2024 Charles Tapley Hoyt  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 10501632c0ce1f48c3a3fd7c1e09c96520d86ac174cc04237bd4214f682f8e7e
name: python-biopandas
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Machine Learning Library Extensions
url: https://github.com/rasbt/biopandas
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biopandas-0.5.1-1.src.rpm
checksum_type: sha256
description:
  If you have any questions or comments about biopandas,
  please feel free to contact me via
  eMail: mail@sebastianraschka.com
  or Twitter: https://twitter.com/rasbt
  This project is hosted at https://github.com/rasbt/biopandas
  The documentation can be found at http://rasbt.github.io/biopandas/


pkgId: bf211fd47adc0d146358ef32bab2a5eac5de18db799b06a5d4ea82bc840e8f88
name: python-biopb
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A place for collecting protobuf definitions for bio-research data
url: https://github.com/jiyuuchc/biopb
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biopb-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A place for collecting protobuf definitions for bio-research data. Currently it has only two packages

  1. `biopb.ome` Microscopy data representation modeled after [OME-XML](https://ome-model.readthedocs.io/en/stable/ome-xml/index.html).
  2. `biopb.image` Image processing protocols. Current focus is single-cell segmentation, designed originally for the [Lacss](https://github.com/jiyuuchc/lacss/) project.


  [Documentation](https://jiyuuchc.github.io/biopb/)

rpm_license:
  MIT License  Copyright (c) 2024 Ji Yu  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: af89f3df3576f24bbfc5351d3888f08c060635032f84681d633271b893fca4f3
name: python-biophony
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Random generation of genetic files
url: https://gitlab.com/cnrgh/databases/biophony
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biophony-1.2.1-1.src.rpm
checksum_type: sha256
description:
  `biophony` is a package for generating random genetic data files intended specifically for testing and validation.
  Real genetic data is often too large, lacks flexibility, or raises privacy concerns, making it
  unsuitable for thorough testing.
  `biophony` makes it simpler to test software in different scenarios without needing real data,
  enabling focused and efficient development and validation.



  `biophony` requires at least Python 3.11 to work.

  To install with `pip`, run:

  ```bash
  pip install biophony
  ```





  `biophony` provides the following CLIs to generate data:

  - `gen-cov`: generates a BED file with custom depth,
  - `gen-fasta`: generates a FASTA file with a custom size sequence,
  - `gen-fastavar`: generates a FASTA file with custom size sequences,
    each with `n` variants with control over insertion, deletion and mutation rate,
  - `gen-fastq`: generates a FASTQ file with custom read count and size,
  - `gen-vcf`: generates a VCF file from a FASTA file, with control over insertion, deletion and mutation rate.

  CLIs that read and / or write data do it on `stdin` and `stdout` by default,
  thus permitting to chain operations with the pipe operator `|`.

  For exemple, run the following command to generate a VCF with 2% SNP, 1% INS and 1% DEL:

  ```bash
  gen-fasta | gen-vcf --snp-rate 0.02 --ins-rate 0.01 --del-rate 0.01
  ```

  To save the generated content, you can either use the regular output operator `>` to redirect `stdout` to a file or
  use the dedicated option:

  ```bash
  gen-fasta | gen-vcf --snp-rate 0.02 --ins-rate 0.01 --del-rate 0.01 > test.vcf  # redirect
  gen-fasta | gen-vcf --snp-rate 0.02 --ins-rate 0.01 --del-rate 0.01 -o test.vcf  # dedicated option
  ```



  You can also use the Python API to generate random genetic data files in your scripts.

  Link to the Python API documentation: https://cnrgh.gitlab.io/databases/biophony/.





  - Fix `Invalid cross-device link` error that occurred with `gen-vcf`,
    in environments where `/tmp` and the VCF output parent directory (`--output-vcf` option)
    were not on the same partition / filesystem. This error was occurring in the GitLab CI pipeline.



  - Provide type annotations by adding a `py.typed` marker file.
  - Export `MutSim` class to allow generation of VCF files in scripts.
  - Generate documentation with `sphinx` and `sphinx-autoapi`.
  - Improve `README.md`.



  - Allow to output gzipped files with gen-fasta and gen-fastq.
  - New gen-fastq script to generate FASTQ files.



  - gen-vcf: correct usage of file path to pass to mutation-simulator.
  - gen-fasta: disable header tag line (comment line) by default.

rpm_license:
  CeCILL FREE SOFTWARE LICENSE AGREEMENT  Version 2.1 dated 2013-06-21   Notice  This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:  * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.  The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre]) license are:  Commissariat à l'énergie atomique et aux énergies alternatives - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.  Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.  Institut National de Recherche en Informatique et en Automatique - Inria, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.   Preamble  The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model.  The exercising of this right is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions.  In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.  In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.  This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.  Frequently asked questions can be found on the official website of the CeCILL licenses family (http://www.cecill.info/index.en.html) for any necessary clarification.   Article 1 - DEFINITIONS  For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:  Agreement: means this license agreement, and its possible subsequent versions and annexes.  Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement.  Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement.  Modified Software: means the Software modified by at least one Contribution.  Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.  Object Code: means the binary files originating from the compilation of the Source Code.  Holder: means the holder(s) of the economic rights over the Initial Software.  Licensee: means the Software user(s) having accepted the Agreement.  Contributor: means a Licensee having made at least one Contribution.  Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.  Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules.  Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software.  External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run.  Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space.  GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc.  GNU Affero GPL: means the GNU Affero General Public License version 3 or any subsequent version, as published by the Free Software Foundation Inc.  EUPL: means the European Union Public License version 1.1 or any subsequent version, as published by the European Commission.  Parties: mean both the Licensee and the Licensor.  These expressions may be used both in singular and plural form.   Article 2 - PURPOSE  The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 <#scope> hereinafter for the whole term of the protection granted by the rights over said Software.   Article 3 - ACCEPTANCE  3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:  * (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; * (ii) the first time the Licensee exercises any of the rights granted hereunder.  3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 <#accepting> hereinabove, and the Licensee hereby acknowledges that it has read and understood it.   Article 4 - EFFECTIVE DATE AND TERM   4.1 EFFECTIVE DATE  The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1 <#accepting>.   4.2 TERM  The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.   Article 5 - SCOPE OF RIGHTS GRANTED  The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.  Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.   5.1 RIGHT OF USE  The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:  1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.  2. loading, displaying, running, or storing the Software on any or all medium.  3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.   5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS  The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software.  The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof.   5.3 RIGHT OF DISTRIBUTION  In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.  The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.   5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION  The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:  1. a copy of the Agreement,  2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,  and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software for a period of at least three years from the distribution of the Software, it being understood that the additional acquisition cost of the Source Code shall not exceed the cost of the data transfer.   5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE  When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement.  The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:  1. a copy of the Agreement,  2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,  and, in the event that only the object code of the Modified Software is redistributed,  3. a note stating the conditions of effective access to the full source code of the Modified Software for a period of at least three years from the distribution of the Modified Software, it being understood that the additional acquisition cost of the source code shall not exceed the cost of the data transfer.   5.3.3 DISTRIBUTION OF EXTERNAL MODULES  When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement.   5.3.4 COMPATIBILITY WITH OTHER LICENSES  The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL, GNU Affero GPL and/or EUPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.  The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, GNU Affero GPL and/or EUPL and distribute that entire code under the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.   Article 6 - INTELLECTUAL PROPERTY   6.1 OVER THE INITIAL SOFTWARE  The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.  The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2 <#term>.   6.2 OVER THE CONTRIBUTIONS  The Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.   6.3 OVER THE EXTERNAL MODULES  The Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution.   6.4 JOINT PROVISIONS  The Licensee expressly undertakes:  1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software;  2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not.  The Licensee undertakes not to directly or indirectly infringe the intellectual property rights on the Software of the Holder and/or Contributors, and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.   Article 7 - RELATED SERVICES  7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.  However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.  7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.   Article 8 - LIABILITY  8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.  8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.   Article 9 - WARRANTY  9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.  The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.  9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5 <#scope>).  9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 <#good-faith> and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.  Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.  9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal expertise for its defense. Such technical and legal expertise shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.   Article 10 - TERMINATION  10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.  10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.   Article 11 - MISCELLANEOUS   11.1 EXCUSABLE EVENTS  Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.  11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.  11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.  11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.   11.5 LANGUAGE  The Agreement is drafted in both French and English and both versions are deemed authentic.   Article 12 - NEW VERSIONS OF THE AGREEMENT  12.1 Any person is authorized to duplicate and distribute copies of this Agreement.  12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.  12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4 <#compatibility>.   Article 13 - GOVERNING LAW AND JURISDICTION  13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.  13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party.


pkgId: eca6e298b6288c1e63557c75a4497d086682c5bf61556d08555ff329f1fde919
name: python-bioplotz
arch: src
version: 0.1.0.dev14
epoch: 0
release: 1
summary: A python package for drawing some bioinformatic pictures.
url: https://github.com/sc-zhang/bioplotz
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioplotz-0.1.0.dev14-1.src.rpm
checksum_type: sha256
description:
  [![Latest PyPI version](https://img.shields.io/pypi/v/bioplotz.svg)](https://pypi.python.org/pypi/bioplotz)
  [![Downloads](https://static.pepy.tech/badge/bioplotz)](https://pepy.tech/project/bioplotz)



  Python modules:
    - numpy
    - matplotlib
    - pandas



  ```bash
  pip install bioplotz
  ```


  ```bash
  pip install git+https://github.com/sc-zhang/bioplotz.git --user
  ```





  ```python
  import bioplotz as bp

  fig, ax = bp.manhattan(data, threshold=0, color=['orange', 'green'], threshold_line_color='blue', log_base=0,
                         reverse=False, xtick_labels=True, ytick_labels=True, ax=None, marker='.', s=1, **kwargs)
  ```
  | parameter                | value type    | explain                                                                                                                                                                                                                                                                                                                                                              |
  |--------------------------|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | **data**                 | dict<br>list  | **dict** key: block name<br>&ensp;&ensp;&ensp;&ensp;value: [[x1,x2,...,xn], [y1,y2,...,yn]]<br>**list** is a list like: [[x1,y1], [x2, y2], ..., [xn, yn]]                                                                                                                                                                                                           |
  | **threshold**            | value<br>list | **value** if only one threshold line to plot, Notice: if log_base was set, threshold values should be calculated with same log_base manunally, if reverse is True, threshold values should be set to its opposite number<br>**list** if more than one threshold line need to plot, a list can be used for different lines, like: [threshold_value1, threshol_value2] |
  | **color**                | list          | **color** is a list used for blocks, if the count of block greater than color count, it will be used circularly                                                                                                                                                                                                                                                      |
  | **threshold_line_color** | value<br>list | **value** if **threshold** is a single value<br>**list** if **threshold** is a list                                                                                                                                                                                                                                                                                  |
  | **threshold_line_width** | value         | **value** the line width of threshold lines                                                                                                                                                                                                                                                                                                                          |
  | **block_line_width**     | value         | **value** if there are only one color, the block line will display as border, the width is set by this parameter                                                                                                                                                                                                                                                     |
  | **log_base**             | value         | log_base = 0 means not calucate value with log<br>log_base != 0 means log base for log values with it                                                                                                                                                                                                                                                                |
  | **reverse**              | Boolean       | if all data lower than 0, you may use it to show opposite values                                                                                                                                                                                                                                                                                                     |
  | **other parameters**     | value         | same with parameters used in **pyplot.scatter**                                                                                                                                                                                                                                                                                                                      |

  <table align="center">
  <tr>
  <td><img width=600 src="examples/manhattan.png"></td>
  </tr>
  </table>



  ```python
  import matplotlib.pyplot as plt
  import bioplotz as bp

  fig, ax, mapper = bp.chromosome(chr_len_db, chr_order, bed_data, centro_pos, value_type="numeric", orientation="vertical", **kwargs)
  plt.colorbar(mapper, ax=ax, shrink=0.5)
  ```
  | parameter            | value type                     | Optional | Default      | explain                                                                                                                                                                                                                                                                                                           |
  |----------------------|--------------------------------|----------|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | **chr_len_db**       | dict                           | No       | -            | **key**: chromosome name<br>**value**: chromosome length                                                                                                                                                                                                                                                          |
  | **chr_order**        | list                           | Yes      | None         | **list**: the custom chromosome order, like: ["Chr1", "Chr3", "Chr2"]<br>must same with keys in chr_len                                                                                                                                                                                                           |
  | **bed_data**         | list                           | Yes      | None         | **list**: two dimension list, like: [[chrome name, start pos, end pos, value/color]]                                                                                                                                                                                                                              |
  | **centro_pos**       | dict                           | Yes      | None         | **key**: chromosome name<br>**value**: middle position of centromere                                                                                                                                                                                                                                              |
  | **value_type**       | str                            | Yes      | numeric      | **numeric**: the 4th column of bed_data should be value<br>**color**: the 4th column of bed_data is color<br>**marker**: different with other two types, it need 5 columns, the 4th column of bed_data is marker, the 5th column is color (marker is same with the parameter which be used in **pyplot.scatter**) |
  | **orientation**      | str                            | Yes      | vertical     | "vertical" or "horizontal"                                                                                                                                                                                                                                                                                        |
  | **cmap**             | str                            | Yes      | gist_rainbow | **cmap** for colorbar                                                                                                                                                                                                                                                                                             |
  | **cmap_parts**       | int                            | Yes      | 100          | how many parts for splitting cmap                                                                                                                                                                                                                                                                                 |
  | **s**                | float or array-like, shape(n,) | Yes      | None         | same with parameter s use in **pyplot.scatter**                                                                                                                                                                                                                                                                   |
  | **other parameters** | value                          | Yes      | None         | same with parameters used in **pyplot.plot**                                                                                                                                                                                                                                                                      |

  - If value_type is numeric, the return value clb will be colorbar, else None
  <table align="center">
  <tr>
  <td><img width=500 height=270 src="examples/chromosome.png"></td>
  <td><img width=500 height=270 src="examples/chromosome_h.png"></td>
  </tr>
  </table>



  ```python
  import bioplotz as bp

  fig, ax = bp.genecluster(gene_list)
  ```
  | parameter     | value type  | Optional | Default | explain                                                                                                                                          |
  |---------------|-------------|----------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------|
  | **gene_list** | list        | No       | -       | **list**: 2-dimension list, like [[gene name, start pos, end pos, direct(+/-), color], ..., [gene name, start pos, end pos, direct(+/-), color]] |
  | **edgecolor** | list<br>str | Yes      | None    | **list**: same length with gene_list, like: ["green", "blue", ..., "red"]<br>**str**: common edge color for all genes                            |
  | **edgewidth** | int         | Yes      | 1       | edge width for all genes                                                                                                                         |
  | **lw**        | int         | Yes      | 3       | line width to show the genome backbone                                                                                                           |

  **Notice**, the best figsize should be (gene count, 1), for example: plt.figure(figsize=(16, 1)), and the bbox_inches parameter which in savefig should be 'tight'.

  <table align="center">
  <tr>
  <td><img width=600 src="examples/genecluster.png"></td>
  </tr>
  </table>



  ```python
  import bioplotz as bp

  fig, ax = bp.multialign(data)
  ```
  | parameter                      | value type | Optional | Default | explain                                                           |
  |--------------------------------|------------|----------|---------|-------------------------------------------------------------------|
  | **data**                       | dict       | No       | -       | **key**: gene name<br>**value**: alignment sequence               |
  | **match_color**                | str        | Yes      | blue    | color of matched bases                                            |
  | **match_background_color**     | str        | Yes      | None    | background color of matched bases                                 |
  | **mismatch_color**             | str        | Yes      | red     | color of mismatched bases                                         |
  | **mismatch_background_color**  | str        | Yes      | None    | background color of mismatched bases                              |
  | **base_per_line**              | int        | Yes      | 80      | base count to display for each line                               |
  | **highlight_positions**        | list       | Yes      | None    | positions for highlighting, 0-base                                |
  | **highlight_color**            | str        | Yes      | green   | color of highlighting positions in highlight_positions            |
  | **highlight_background_color** | str        | Yes      | None    | background color of highlighting positions in highlight_positions |
  | ****kwargs**                   | any        | Yes      | -       | same with which use in ax.text                                    |

  **Notice**, the figsize should be (base_per_line/10, x) where x=align_length/base_per_line*gene_count/5, and the font must be  monospaced,
  like "Courier New", that sometimes user need add codes as following.
  ```python
  import matplotlib as mpl
  import bioplotz as bp

  basefont = mpl.font_manager.FontProperties(fname="/path/to/font.ttf")
  fig, ax = bp.multialign(data, fontproperties=basefont)
  ```
  or
  ```python
  plt.rcParams['font.sans-serif'] = 'Courier New'
  ```
  <table align="center">
  <tr>
  <td><img width=600 src="examples/multialign.png"></td>
  </tr>
  </table>


pkgId: f4034ca62c8b2bddf2473990edca26daa1915b678b88f2d799b78cefa3a94dc2
name: python-bioplotz
arch: src
version: 0.1.0.dev15
epoch: 0
release: 1
summary: A python package for drawing some bioinformatic pictures.
url: https://github.com/sc-zhang/bioplotz
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioplotz-0.1.0.dev15-1.src.rpm
checksum_type: sha256
description:
  [![Latest PyPI version](https://img.shields.io/pypi/v/bioplotz.svg)](https://pypi.python.org/pypi/bioplotz)
  [![Downloads](https://static.pepy.tech/badge/bioplotz)](https://pepy.tech/project/bioplotz)



  Python modules:
    - numpy
    - matplotlib
    - pandas



  ```bash
  pip install bioplotz
  ```


  ```bash
  pip install git+https://github.com/sc-zhang/bioplotz.git --user
  ```





  ```python
  import bioplotz as bp

  fig, ax = bp.manhattan(data, threshold=0, color=['orange', 'green'], threshold_line_color='blue', log_base=0,
                         reverse=False, xtick_labels=True, ytick_labels=True, ax=None, marker='.', s=1, **kwargs)
  ```
  | parameter                | value type    | explain                                                                                                                                                                                                                                                                                                                                                              |
  |--------------------------|---------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | **data**                 | dict<br>list  | **dict** key: block name<br>&ensp;&ensp;&ensp;&ensp;value: [[x1,x2,...,xn], [y1,y2,...,yn]]<br>**list** is a list like: [[x1,y1], [x2, y2], ..., [xn, yn]]                                                                                                                                                                                                           |
  | **threshold**            | value<br>list | **value** if only one threshold line to plot, Notice: if log_base was set, threshold values should be calculated with same log_base manunally, if reverse is True, threshold values should be set to its opposite number<br>**list** if more than one threshold line need to plot, a list can be used for different lines, like: [threshold_value1, threshol_value2] |
  | **color**                | list          | **color** is a list used for blocks, if the count of block greater than color count, it will be used circularly                                                                                                                                                                                                                                                      |
  | **threshold_line_color** | value<br>list | **value** if **threshold** is a single value<br>**list** if **threshold** is a list                                                                                                                                                                                                                                                                                  |
  | **threshold_line_width** | value         | **value** the line width of threshold lines                                                                                                                                                                                                                                                                                                                          |
  | **block_line_width**     | value         | **value** if there are only one color, the block line will display as border, the width is set by this parameter                                                                                                                                                                                                                                                     |
  | **log_base**             | value         | log_base = 0 means not calucate value with log<br>log_base != 0 means log base for log values with it                                                                                                                                                                                                                                                                |
  | **reverse**              | Boolean       | if all data lower than 0, you may use it to show opposite values                                                                                                                                                                                                                                                                                                     |
  | **other parameters**     | value         | same with parameters used in **pyplot.scatter**                                                                                                                                                                                                                                                                                                                      |

  <table align="center">
  <tr>
  <td><img width=600 src="examples/manhattan.png"></td>
  </tr>
  </table>



  ```python
  import matplotlib.pyplot as plt
  import bioplotz as bp

  fig, ax, mapper = bp.chromosome(chr_len_db, chr_order, bed_data, centro_pos, value_type="numeric", orientation="vertical", **kwargs)
  plt.colorbar(mapper, ax=ax, shrink=0.5)
  ```
  | parameter            | value type                     | Optional | Default      | explain                                                                                                                                                                                                                                                                                                           |
  |----------------------|--------------------------------|----------|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | **chr_len_db**       | dict                           | No       | -            | **key**: chromosome name<br>**value**: chromosome length                                                                                                                                                                                                                                                          |
  | **chr_order**        | list                           | Yes      | None         | **list**: the custom chromosome order, like: ["Chr1", "Chr3", "Chr2"]<br>must same with keys in chr_len                                                                                                                                                                                                           |
  | **bed_data**         | list                           | Yes      | None         | **list**: two dimension list, like: [[chrome name, start pos, end pos, value/color]]                                                                                                                                                                                                                              |
  | **centro_pos**       | dict                           | Yes      | None         | **key**: chromosome name<br>**value**: middle position of centromere                                                                                                                                                                                                                                              |
  | **value_type**       | str                            | Yes      | numeric      | **numeric**: the 4th column of bed_data should be value<br>**color**: the 4th column of bed_data is color<br>**marker**: different with other two types, it need 5 columns, the 4th column of bed_data is marker, the 5th column is color (marker is same with the parameter which be used in **pyplot.scatter**) |
  | **orientation**      | str                            | Yes      | vertical     | "vertical" or "horizontal"                                                                                                                                                                                                                                                                                        |
  | **cmap**             | str                            | Yes      | gist_rainbow | **cmap** for colorbar                                                                                                                                                                                                                                                                                             |
  | **cmap_parts**       | int                            | Yes      | 100          | how many parts for splitting cmap                                                                                                                                                                                                                                                                                 |
  | **s**                | float or array-like, shape(n,) | Yes      | None         | same with parameter s use in **pyplot.scatter**                                                                                                                                                                                                                                                                   |
  | **fig_ratio**        | float                          | Yes      | None         | if plot with subplots, use this parameter to keep the arcs of chromosomes correct, for "vertical", this parameter should be fig_width/fig_height, otherwise, fig_height/fig_width                                                                                                                                 |
  | **other parameters** | value                          | Yes      | None         | same with parameters used in **pyplot.plot**                                                                                                                                                                                                                                                                      |

  - If value_type is numeric, the return value will be a mapper, else None
  <table align="center">
  <tr>
  <td><img width=500 height=270 src="examples/chromosome.png"></td>
  <td><img width=500 height=270 src="examples/chromosome_h.png"></td>
  </tr>
  </table>



  ```python
  import bioplotz as bp

  fig, ax = bp.genecluster(gene_list)
  ```
  | parameter     | value type  | Optional | Default | explain                                                                                                                                          |
  |---------------|-------------|----------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------|
  | **gene_list** | list        | No       | -       | **list**: 2-dimension list, like [[gene name, start pos, end pos, direct(+/-), color], ..., [gene name, start pos, end pos, direct(+/-), color]] |
  | **edgecolor** | list<br>str | Yes      | None    | **list**: same length with gene_list, like: ["green", "blue", ..., "red"]<br>**str**: common edge color for all genes                            |
  | **edgewidth** | int         | Yes      | 1       | edge width for all genes                                                                                                                         |
  | **lw**        | int         | Yes      | 3       | line width to show the genome backbone                                                                                                           |

  **Notice**, the best figsize should be (gene count, 1), for example: plt.figure(figsize=(16, 1)), and the bbox_inches parameter which in savefig should be 'tight'.

  <table align="center">
  <tr>
  <td><img width=600 src="examples/genecluster.png"></td>
  </tr>
  </table>



  ```python
  import bioplotz as bp

  fig, ax = bp.multialign(data)
  ```
  | parameter                      | value type | Optional | Default | explain                                                           |
  |--------------------------------|------------|----------|---------|-------------------------------------------------------------------|
  | **data**                       | dict       | No       | -       | **key**: gene name<br>**value**: alignment sequence               |
  | **match_color**                | str        | Yes      | blue    | color of matched bases                                            |
  | **match_background_color**     | str        | Yes      | None    | background color of matched bases                                 |
  | **mismatch_color**             | str        | Yes      | red     | color of mismatched bases                                         |
  | **mismatch_background_color**  | str        | Yes      | None    | background color of mismatched bases                              |
  | **base_per_line**              | int        | Yes      | 80      | base count to display for each line                               |
  | **highlight_positions**        | list       | Yes      | None    | positions for highlighting, 0-base                                |
  | **highlight_color**            | str        | Yes      | green   | color of highlighting positions in highlight_positions            |
  | **highlight_background_color** | str        | Yes      | None    | background color of highlighting positions in highlight_positions |
  | ****kwargs**                   | any        | Yes      | -       | same with which use in ax.text                                    |

  **Notice**, the figsize should be (base_per_line/10, x) where x=align_length/base_per_line*gene_count/5, and the font must be  monospaced,
  like "Courier New", that sometimes user need add codes as following.
  ```python
  import matplotlib as mpl
  import bioplotz as bp

  basefont = mpl.font_manager.FontProperties(fname="/path/to/font.ttf")
  fig, ax = bp.multialign(data, fontproperties=basefont)
  ```
  or
  ```python
  plt.rcParams['font.sans-serif'] = 'Courier New'
  ```
  <table align="center">
  <tr>
  <td><img width=600 src="examples/multialign.png"></td>
  </tr>
  </table>


pkgId: 08249d78eaf56cddc872cfe79b3c5c0a3c1772705f762521934e6253e755622e
name: python-bioprocessnexus
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: README.md
url: https://pypi.org/project/bioprocessnexus/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioprocessnexus-1.0.4-1.src.rpm
checksum_type: sha256
description:
  The BioProcessNexus is a project to enable free sharing of techno economic process models and life cycle analsis via surrogate models. The heartpieces of the project are an open-source python software for the generation and analysis of surrogate models and a data repository containing Monte-Carlo data from original models as well as pre-trained surrogate models.

  For more information visit the [documentation](https://bioprocessnexus.readthedocs.io/en/latest/)!





  The BioProcessNexus can be launched directly by downloading bioprocess.exe from [here](https://drive.boku.ac.at/d/3e0e8e499c7c402190de/).



  You can install the development version of the BioProcessNexus from PyPi with:

  ```
  pip install bioprocessnexus
  ```

  All dependencies can be found in the requirements.txt file and be installed with:

  ```
  pip install -r path/to/requirements.txt
  ```

  after downloading the file.

  The GUI can the be launched by importing the bioprocessnexus and running bioprocessnexus.launch_nexus() in python:

  ``` python
  import bioprocessnexus
  bioprocessnexus.launch_nexus()
  ```


pkgId: 8748168b9829799d0ea4aefd3b2c74cb848c7a70555623687c27b5f0bd23301e
name: python-bioprov
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: BioProv - Provenance capture for bioinformatics workflows
url: https://github.com/vinisalazar/BioProv
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioprov-0.1.24-1.src.rpm
checksum_type: sha256
description:
  Tests | [![Build Status](https://travis-ci.org/vinisalazar/BioProv.svg?branch=master)](https://travis-ci.org/vinisalazar/BioProv) |  [![tests](https://github.com/vinisalazar/bioprov/workflows/tests/badge.svg?branch=master)](https://github.com/vinisalazar/bioprov/actions?query=workflow%3Atests) | [![Coverage Status](https://coveralls.io/repos/github/vinisalazar/BioProv/badge.svg?branch=master&service=github)](https://coveralls.io/github/vinisalazar/BioProv?branch=master&service=github)
  Docs | [![Docs status](https://readthedocs.org/projects/bioprov/badge/?version=latest)](https://bioprov.readthedocs.io/en/latest/?badge=latest) | [![License](https://img.shields.io/github/license/vinisalazar/bioprov)](https://github.com/vinisalazar/BioProv/blob/master/LICENSE) | [![binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/vinisalazar/bioprov/master?filepath=docs%2Ftutorials%2F)
  BioProv is a Python library for [W3C-PROV](https://www.w3.org/TR/prov-overview/) representation of bioinformatics workflows.
   It enables you to quickly write workflows and to describe relationships between samples, files, users and programs.
  Please see the [tutorials](./docs/tutorials/introduction.ipynb) for a more detailed introduction and
   visit [ReadTheDocs](https://bioprov.readthedocs.io/) for the complete documentation.

  ```py
  >>> import bioprov as bp

  >>> sample = bp.Sample("mysample")
  >>> genome = bp.File("mysample.fasta", "genome")
  >>> sample.add_files(genome)

  >>> output = sample.files["blast_out"] = bp.File("mysample.blast.tsv", "blast_out")
  >>> blastn = bp.Program("blastn",
                          params={"-query": sample.files["genome"],
                                  "-db": "mydb.fasta", "-out": output}
                          )
  >>> sample.add_programs(blastn)

  >>> sample.run_programs()

  >>> proj = bp.Project((sample,), tag="example_project")
  >>> proj.to_json()

  >>> prov = bp.BioProvDocument(proj)

  >>> prov.write_provn()  # human-readable text format
  >>> prov.dot.write_pdf()  # graphical format
  ```
  BioProv also has a command-line application to run preset workflows.
  ```
  $ bioprov -h
  usage: bioprov [-h] [--show_config | --show_db | --clear_db | -v | -l]
                 {genome_annotation,blastn,kaiju} ...
  BioProv command-line application. Choose a command to begin.
  optional arguments:
    -h, --help            show this help message and exit
    --show_config         Show location of config file.
    --show_db             Show location of database file.
    --clear_db            Clears all records in database.
    -v, --version         Show BioProv version
    -l, --list            List Projects in the BioProv database.
  workflows:
    {genome_annotation,blastn,kaiju}
  ```
  BioProv is built with the [Biopython](https://biopython.org/) and [Pandas](http://pandas.pydata.org/) libraries.
  You can import data into BioProv using Pandas objects.
  ```py

  >>> samples = bp.read_csv("my_dataframe.tsv", sep="\t", sequencefile_cols="assembly")

  >>> df = pd.read_csv("my_dataframe.tsv", sep="\t")

  >>> df["assembly"] = "assembly_directory/" + df["assembly"]

  >>> project = bp.from_df(df, sequencefile_cols="assembly", source_file="my_dataframe.tsv")

  >>> sample1 = project['sample1']

  >>> project.to_csv()
  ```

  ```sh

  $ pip install bioprov

  $ conda install -c conda-forge -c bioconda bioprov

  $ git clone https://github.com/vinisalazar/bioprov && cd bioprov;     # download
  $ conda env create -f environment.yaml && conda activate bioprov;     # install dependencies
  $ pip install . && pytest;                                            # install and test
  ```
  **Important!** BioProv requires [Prodigal](https://github.com/hyattpd/Prodigal) to be tested. Otherwise tests will fail.
  Contributions are welcome!
  **BioProv is in active development and no warranties are provided (please see the License).**

  BioProv requires the follow dependencies to run. Also see the [setup](./setup.py) and [environment](./environment.yaml) files.
  - biopython
  - coolname
  - coveralls
  - dataclasses
  - pandas
  - prodigal
  - prov
  - provstore-api
  - pydot
  - pytest
  - pytest-cov
  - tqdm
  - tinydb


pkgId: c65bcdb687e5021cfa81fe79a2dacc8143e21f2e8970dd5b015b8a65b0609147
name: python-biopython
arch: src
version: 1.84
epoch: 0
release: 1
summary: Freely available tools for computational molecular biology.
url: https://biopython.org/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biopython-1.84-1.src.rpm
checksum_type: sha256
description:
  The Biopython Project is an international association of developers of freely
  available Python tools for computational molecular biology.
  This README file is intended primarily for people interested in working
  with the Biopython source code, either one of the releases from the
  http://biopython.org website, or from our repository on GitHub
  https://github.com/biopython/biopython
  Our user-centric documentation, `The Biopython Tutorial and Cookbook, and API
  documentation <https://biopython.org/docs/latest/>`_, is generated from our
  repository using Sphinx.
  The `NEWS <https://github.com/biopython/biopython/blob/master/NEWS.rst>`_
  file summarises the changes in each release of Biopython, alongside the
  `DEPRECATED
  <https://github.com/biopython/biopython/blob/master/DEPRECATED.rst>`_
  file which notes API breakages.
  The Biopython package is open source software made available under generous
  terms. Please see the `LICENSE
  <https://github.com/biopython/biopython/blob/master/LICENSE.rst>`_ file for
  further details.
  If you use Biopython in work contributing to a scientific publication, we ask
  that you cite our application note (below) or one of the module specific
  publications (listed on our website):
  Cock, P.J.A. et al. Biopython: freely available Python tools for computational
  molecular biology and bioinformatics. Bioinformatics 2009 Jun 1; 25(11) 1422-3
  https://doi.org/10.1093/bioinformatics/btp163 pmid:19304878


pkgId: 537392e495527ef7dd5a7fb1050f8ea2cb8c92034e9dcecdc1f270f6781449ca
name: python-bioregistry
arch: src
version: 0.11.24
epoch: 0
release: 1
summary: Integrated registry of biological databases and nomenclatures
url: https://github.com/biopragmatics/bioregistry
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioregistry-0.11.24-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/biopragmatics/bioregistry/raw/main/docs/source/logo.png" height="150">
  </p>

  <h1 align="center">
      Bioregistry
  </h1>

  <p align="center">
      <a href="https://github.com/biopragmatics/bioregistry/actions?query=workflow%3ATests">
          <img alt="Tests" src="https://github.com/biopragmatics/bioregistry/workflows/Tests/badge.svg" />
      </a>
      <a href="https://pypi.org/project/bioregistry">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/bioregistry" />
      </a>
      <a href="https://pypi.org/project/bioregistry">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/bioregistry" />
      </a>
      <a href="https://github.com/biopragmatics/bioregistry/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/bioregistry" />
      </a>
      <a href='https://bioregistry.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/bioregistry/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="https://zenodo.org/badge/latestdoi/319481281">
          <img src="https://zenodo.org/badge/319481281.svg" alt="DOI">
      </a>
      <a href="https://github.com/psf/black">
          <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
      </a>
      <a href="https://github.com/biopragmatics/bioregistry/blob/main/.github/CODE_OF_CONDUCT.md">
          <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" />
      </a>
  </p>

  <p align="center">
     A community-driven integrative meta-registry of life science databases, ontologies, and other resources.
     <br />More information <a href="https://bioregistry.io/summary">here</a>.
  </p>

  The Bioregistry can be accessed, searched, and queried through its associated
  website at https://bioregistry.io.



  The underlying data of the Bioregistry can be downloaded (or edited) directly
  from
  [here](https://github.com/biopragmatics/bioregistry/blob/main/src/bioregistry/data/).
  Several exports to YAML, TSV, and RDF, including consensus views over the
  registry, are built on a weekly basis and can be downloaded via the
  [`exports/`](https://github.com/biopragmatics/bioregistry/tree/main/exports)
  directory.

  The manually curated portions of these data are available under the
  [CC0 1.0 Universal License](https://creativecommons.org/publicdomain/zero/1.0/).
  Aggregated data are redistributed under their original licenses.



  Contributions are both welcomed and encouraged. Contribution guidelines for new
  prefix requests, record edits, record removals, and code updates are available
  in [CONTRIBUTING.md](docs/CONTRIBUTING.md).

  The most simple contribution is to submit an issue:

  - Submit a new prefix using the
    [issue template](https://github.com/biopragmatics/bioregistry/issues/new?assignees=cthoyt&labels=New%2CPrefix&template=new-prefix.yml&title=Add+prefix+%5BX%5D).
    A new pull request will be generated automatically for you.
  - Update an existing record using one of the
    [existing issue templates](https://github.com/biopragmatics/bioregistry/issues/new/choose)
    (e.g., for updating a record's regular expression, merging two prefixes).
  - For any updates that don't have a corresponding template, feel free to start
    with a [blank issue](https://github.com/biopragmatics/bioregistry/issues/new).

  If you want to make a direct contribution, feel free to make edits directly to
  the
  [bioregistry.json](https://github.com/biopragmatics/bioregistry/blob/main/src/bioregistry/data/bioregistry.json)
  file either through the GitHub interface or locally by
  [forking the repository](https://github.com/biopragmatics/bioregistry/blob/main/docs/CONTRIBUTING.md#code-contribution).

  If you want to make a contribution but don't know where to start, you can check
  [this list](https://biopragmatics.github.io/bioregistry/curation/) of curation
  To-Do's that's automatically generated weekly, including more detailed
  information on how to contribute.



  The Bioregistry is maintained by a Review Team and Core Development team whose
  memberships and duties are described in the
  [Project Governance](docs/GOVERNANCE.md).





  The Bioregistry runs some automated tests weekly to check that various metadata
  haven't gone stale. For example, it checks that the homepages are still
  available and that each provider URL is still able to resolve.

  It has a dedicated
  [dashboard](https://biopragmatics.github.io/bioregistry/health) that is not part
  of the main Bioregistry site.



  The database is automatically updated daily thanks to scheduled workflows in
  GitHub Actions. The workflow's configuration can be found
  [here](https://github.com/biopragmatics/bioregistry/blob/main/.github/workflows/update.yml)
  and the last run can be seen
  [here](https://github.com/biopragmatics/bioregistry/actions?query=workflow%3A%22Update+Data%22).
  Further, a
  [changelog](https://github.com/biopragmatics/bioregistry/commits?author=actions-user)
  can be recapitulated from the commits of the GitHub Actions bot.

  If you want to manually update the database, run the following:

  ```shell
  $ tox -e update
  ```

  Make sure that you have valid environment variables or `pystow` configurations
  for `BIOPORTAL_API_KEY`, `ECOPORTAL_API_KEY`, `AGROPORTAL_API_KEY`,
  `FAIRSHARING_LOGIN`, and `FAIRSHARING_PASSWORD`.



  The Bioregistry can be installed from
  [PyPI](https://pypi.org/project/bioregistry/) with:

  ```shell
  $ pip install bioregistry
  ```

  It can be installed in development mode for local curation with:

  ```shell
  $ git clone https://github.com/biopragmatics/bioregistry.git
  $ cd bioregistry
  $ pip install --editable .
  ```

  Build the docs locally with `tox -e docs` then view by opening
  `docs/build/html/index.html`.





  The Bioregistry can be used to normalize prefixes across MIRIAM and all the
  (very plentiful) variants that pop up in ontologies in OBO Foundry and the OLS
  with the `normalize_prefix()` function.

  ```python
  from bioregistry import normalize_prefix


  assert 'ncbitaxon' == normalize_prefix('ncbitaxon')


  assert 'chebi' == normalize_prefix("CHEBI")


  assert 'fbbt' == normalize_prefix("FBbt")


  assert 'ncbitaxon' == normalize_prefix('taxonomy')


  assert 'pubchem.compound' == normalize_prefix('pubchem')


  assert 'eccode' == normalize_prefix('ec-code')
  assert 'eccode' == normalize_prefix('EC_CODE')


  assert normalize_prefix('not a real key') is None
  ```



  The Bioregistry supports parsing a CURIE into a pair of normalized prefix and
  identifier using the `parse_curie()` function:

  ```python
  from bioregistry import parse_curie


  assert ('chebi', '1234') == parse_curie('chebi:1234')


  assert ('fbbt', '00007294') == parse_curie('FBbt:00007294')


  assert ('pubchem.compound', '1234') == parse_curie('pubchem:1234')


  assert ('go', '1234') == parse_curie('GO:GO:1234')
  ```

  This will also apply the same normalization rules for prefixes from the previous
  section on normalizing prefixes for the remaining examples.



  The Bioregistry supports converting a CURIE to a canonical CURIE by normalizing
  the prefix and removing redundant namespaces embedded in LUIs with the
  `normalize_curie()` function.

  ```python
  from bioregistry import normalize_curie


  assert 'chebi:1234' == normalize_curie('chebi:1234')


  assert 'pubchem.compound:1234' == normalize_curie('pubchem:1234')


  assert 'fbbt:1234' == normalize_curie('FBbt:1234')


  assert 'go:1234' == normalize_curie('GO:GO:1234')
  ```



  The Bioregistry can be used to parse CURIEs from IRIs due to its vast registry
  of provider URL strings and additional programmatic logic implemented with
  Python. It can parse OBO Library PURLs, IRIs from the OLS and identifiers.org,
  IRIs from the Bioregistry website, and any other IRIs from well-formed providers
  registered in the Bioregistry. The `parse_iri()` function gets a pre-parsed
  CURIE, while the `curie_from_iri()` function makes a canonical CURIE from the
  pre-parsed CURIE.

  ```python
  from bioregistry import curie_from_iri, parse_iri


  assert ('chebi', '24867') == parse_iri('https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867')
  assert 'chebi:24867' == curie_from_iri('https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867')


  assert ('chebi', '24867') == parse_iri('http://purl.obolibrary.org/obo/CHEBI_24867')
  assert 'chebi:24867' == curie_from_iri('http://purl.obolibrary.org/obo/CHEBI_24867')


  assert ('chebi', '24867') == parse_iri('https://www.ebi.ac.uk/ols/ontologies/chebi/terms?iri=http://purl.obolibrary.org/obo/CHEBI_24867')
  assert 'chebi:24867' == curie_from_iri('https://www.ebi.ac.uk/ols/ontologies/chebi/terms?iri=http://purl.obolibrary.org/obo/CHEBI_24867')


  assert ('chebi', '24867') == parse_iri('https://identifiers.org/CHEBI:24867')
  assert ('chebi', '24867') == parse_iri('http://identifiers.org/CHEBI:24867')
  assert ('chebi', '24867') == parse_iri('https://identifiers.org/CHEBI/24867')
  assert ('chebi', '24867') == parse_iri('http://identifiers.org/CHEBI/24867')


  assert ('chebi', '24867') == parse_iri('https://bioregistry.io/chebi:24867')
  ```

  In general, the Bioregistry knows how to parse both the http and https variants
  of any given URI:

  ```python
  from bioregistry import parse_iri

  assert ('neuronames', '268') == parse_iri("http://braininfo.rprc.washington.edu/centraldirectory.aspx?ID=268")
  assert ('neuronames', '268') == parse_iri("https://braininfo.rprc.washington.edu/centraldirectory.aspx?ID=268")
  ```



  You can generate an IRI from either a CURIE or a pre-parsed CURIE (i.e., a
  2-tuple of a prefix and identifier) with the `get_iri()` function. By default,
  it uses the following priorities:

  1. Custom prefix map (`custom`)
  2. First-party IRI (`default`)
  3. Identifiers.org / MIRIAM (`miriam`)
  4. Ontology Lookup Service (`ols`)
  5. OBO PURL (`obofoundry`)
  6. Name-to-Thing (`n2t`)
  7. BioPortal (`bioportal`)

  ```python
  from bioregistry import get_iri

  assert get_iri("chebi", "24867") == 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867'
  assert get_iri("chebi:24867") == 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867'
  ```

  It's possible to change the default priority list by passing an alternate
  sequence of metaprefixes to the `priority` keyword (see above). For example, if
  you're working with OBO ontologies, you might want to make OBO PURLs the highest
  priority and when OBO PURLs can't be generated, default to something else:

  ```python
  from bioregistry import get_iri

  priority = ["obofoundry", "default", "miriam", "ols", "n2t", "bioportal"]
  assert get_iri("chebi:24867", priority=priority) == 'http://purl.obolibrary.org/obo/CHEBI_24867'
  assert get_iri("hgnc:1234", priority=priority) == 'https://bioregistry.io/hgnc:1234'
  ```

  Even deeper, you can add (or override) any of the Bioregistry's default prefix
  map with the `prefix_map` keyword:

  ```python
  from bioregistry import get_iri

  prefix_map = {
     "myprefix": "https://example.org/myprefix/",
     "chebi": "https://example.org/chebi/",
  }
  assert get_iri("chebi:24867", prefix_map=prefix_map) == 'https://example.org/chebi/24867'
  assert get_iri("myprefix:1234", prefix_map=prefix_map) == 'https://example.org/myprefix/1234'
  ```

  A custom prefix map can be supplied in combination with a priority list, using
  the `"custom"` key for changing the priority of the custom prefix map.

  ```python
  from bioregistry import get_iri

  prefix_map = {"lipidmaps": "https://example.org/lipidmaps/"}
  priority = ["obofoundry", "custom", "default", "bioregistry"]
  assert get_iri("chebi:24867", prefix_map=prefix_map, priority=priority) == \
      'http://purl.obolibrary.org/obo/CHEBI_24867'
  assert get_iri("lipidmaps:1234", prefix_map=prefix_map, priority=priority) == \
      'https://example.org/lipidmaps/1234'
  ```

  Alternatively, there are direct functions for generating IRIs for different
  registries:

  ```python
  import bioregistry as br


  assert br.get_bioregistry_iri('chebi', '24867') == 'https://bioregistry.io/chebi:24867'


  assert br.get_default_iri('chebi', '24867') == 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867'


  assert br.get_obofoundry_iri('chebi', '24867') == 'http://purl.obolibrary.org/obo/CHEBI_24867'


  assert br.get_ols_iri('chebi', '24867') ==
         'https://www.ebi.ac.uk/ols/ontologies/chebi/terms?iri=http://purl.obolibrary.org/obo/CHEBI_24867'


  assert br.get_bioportal_iri('chebi', '24867') == \
      'https://bioportal.bioontology.org/ontologies/CHEBI/?p=classes&conceptid=http://purl.obolibrary.org/obo/CHEBI_24867'


  assert br.get_identifiers_org_iri('chebi', '24867') == 'https://identifiers.org/CHEBI:24867'


  assert br.get_n2t_iri('chebi', '24867') == 'https://n2t.net/chebi:24867'
  ```

  Each of these functions could also return `None` if there isn't a provider
  available or if the prefix can't be mapped to the various resources.



  The Bioregistry can be used to generate prefix maps with various flavors
  depending on your context. Prioritization works the same way as when generating
  IRIs.

  ```python
  from bioregistry import get_prefix_map


  prefix_map = get_prefix_map()


  priority = ["obofoundry", "default", "miriam", "ols", "n2t", "bioportal"]
  prefix_map = get_prefix_map(uri_prefix_priority=priority)


  remapping = {"chebi": "CHEBI"}
  prefix_map = get_prefix_map(remapping=remapping)
  ```



  The pattern for an entry in the Bioregistry can be looked up quickly with
  `get_pattern()` if it exists. It prefers the custom curated, then MIRIAM, then
  Wikidata pattern.

  ```python
  import bioregistry

  assert '^GO:\\d{7}$' == bioregistry.get_pattern('go')
  ```

  Entries in the Bioregistry can be checked for deprecation with the
  `is_deprecated()` function. MIRIAM and OBO Foundry don't often agree - OBO
  Foundry takes precedence since it seems to be updated more often.

  ```python
  import bioregistry

  assert bioregistry.is_deprecated('nmr')
  assert not bioregistry.is_deprecated('efo')
  ```

  Entries in the Bioregistry can be looked up with the `get_resource()` function.

  ```python
  import bioregistry

  entry = bioregistry.get_resource('taxonomy')

  ```

  The full Bioregistry can be read in a Python project using:

  ```python
  import bioregistry

  registry = bioregistry.read_registry()
  ```



  After installation with the `[web]` extras, the Bioregistry web application can
  be run with the following code:

  ```shell
  $ python -m pip install bioregistry[web]
  $ bioregistry web
  ```

  to run a web app that functions like Identifiers.org, but backed by the
  Bioregistry. A public instance of this app is hosted by the
  [Gyori Lab for Computational Biomedicine](https://gyorilab.github.io) at
  https://bioregistry.io.





  The code in this repository is licensed under the
  [MIT License](https://github.com/biopragmatics/bioregistry/blob/main/LICENSE).



  If you use the Bioregistry in your code, support us by including our badge in
  your project's README.md:

  ```markdown
  [![Powered by the Bioregistry](https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAoCAYAAACM/rhtAAAACXBIWXMAAAEnAAABJwGNvPDMAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAACi9JREFUWIWtmXl41MUZxz/z291sstmQO9mQG0ISwHBtOOSwgpUQhApWgUfEowKigKI81actypaqFbWPVkGFFKU0Vgs+YgvhEAoqEUESrnDlEEhCbkLYJtlkk9399Y/N/rKbzQXt96+Zed+Z9/t7Z+adeecnuA1s5yFVSGrLOAf2qTiEEYlUZKIAfYdKE7KoBLkQSc4XgkPfXxz/owmT41ZtiVtR3j94eqxQq5aDeASIvkVb12RBtt0mb5xZsvfa/5XgnqTMcI3Eq7IQjwM+7jJJo8YvNhK/qDBUOl8A7JZWWqqu01Jeg6Pd1nW4NuBjjax6eWrRruv/M8EDqTMflmXeB0Jcbb6RIRhmTCJ0ymgC0wYjadTd9nW0tWMu+In63NNU7c3FWtvgJpXrZVlakVGU8/ltEcwzGjU3miI/ABa72vwTB5K45AEi7x2PUEl9fZsHZLuDmgPHuLJpJ82lle6iTSH6mpXp+fnt/Sa4yzhbp22yfwFkgnMaBy17kPhFmQh1997qLxztNkq35XB505fINtf0iz1WvfTQ7Pxdlj4Jdnjuny5yvpEhjHh7FQOGD/YyZi4owS86HJ+QQMDpJaBf3jUXlHD21+8q0y4LDppV/vfNO7+jzV3Pa6SOac0E8I8fSPonpm7JAVR+eRhzwU/Ofj+e49tpT/HdtGXcyLvQJ8HAtCTGfmJCF2dwfpTMz4NszX/uqqdyr+xPyVwoEK+C03PGrDX4GkJ7NBJ+txH/hCgAit7cRlNxOY62dmzmZgwzJvZJUh2gI/xnRmoOHsfe3AqQ/kho0qXs+pLzLh3FgwdT54YKxLsAQq0mbf1zHuTsltZejemHJSrlgGGDPGTXc09zdM5qTi59jZbKOg+Zb1QYI95+XokEQogPDifPDnPJFQ8uCkl8FyGmACQtn4dhxp3KINX7jnHi0ZeJnT8dla8Plbu+48zzfyJ08kh8ggIACB4zlIAhsURm3EnML6eB6Fzep1a+SUt5DS2VddTs+4GQccPRhgV1kowIQRaChhMXAPxkIev/Vl+8R/HgnqTMmI4gjH/iQOIXZSqdzQUlXDB9RPyi+1DrdVx67WMursvCkDERXYxB0ROSIOKecURMG+tBzkXAhbYbZk6teNPLkwmPzUIX71wuMiw+MHx2nEJQrWIFHSdE4pIHlFDisLZxYe1HhIwfTtLK+RSu30rVnlxGvrOapOcW9DsW3vH6CgKS4zxIXlz3Fw8dSaMmcfEcV9XHYbc/DSCZMEkgFoJzY0TeO17pVL7jANbaBoauWUJlTi4VOw+T9sazBKYl0ZB/qV/kALThQRi3vOJB0lpzw0vPMONOtOHOqRcyi7bzkEqanJo3HogBMGROUrziaGundGsOsQsyUPn6UPx2NvELZxIybhinn3uLyx9uVwaW7XbqjxdQmr2X0uy93Dh+Dtlu9zCu9vdj1PsvEWwcii7OwJAXFnoRFCoVhoxJrmr0gOQWo9qBfaorXodOHq0o1x8roN3cSMyC6ZT942uQBIlL53Jl804sV6oY9/fXAGg4WcjFdZuxlFV7GNPFRzFs7VKCRiV7ejJrTa/eDr1rFKXZOQCocEyTgHQAyUdD4B2d4cF8pohg4zC0YUFU7z5C9Jy7sVvbKPtsH6GT0tCGBtFwspBTz/zRixyApbSKk8te5+aZ4l4JdUVQWpIScmQhjGocUjJCRhcTieSjURQTF89FtttpuVaLpaya8Knp1B3OQ5Zlag/nU//9cmScS6EnONrauWjazIQv3kCoVD3quUPS+uAXHU7z1SpATpEQchSA78AwD0WVnxa1XkdjURlCJRGQHMfN/EuEjk9jyr4NRN47Hltjc58Gm0sraTjZ/w3l5BLuKkZJdFzT1f5+3Sq3NZjRDNAjaX1orb2BX2wEmkA9fvGGbvW7Q+OlUu+2wlIqdx+h3dzkJVPrda5iQJ93p+DRqcQ/PhsAw8xJ6AfHdkhuIVvoEribLl/jxKOv4Gi34T8omgnb1yOk7sdTA01AiK3J6yoGgP+gaPwHOdOP6LlTlXb3mNYXAlI8da9/e0pJBZovV2BrakYzQK/I3bg0SsiiCqClqs/0wAPB6UOVo6k3+CdEETwm1aPtP+dLlLJPSKAHOYDWCoVLlYTkKAKcCU4vO7IrhErFsLVLPXZ+V0haDcN+v8xjB9strdQfPavUA0ckefRxWNuwVNS6rBRKQB44r+Lmc5f7TRAgaFQyYzb9Dv/4gd18ASQ8/gsC0zwJNJVcw97aeWmOcDtaAW6eLXZLBchTC8EhWXbW6o+cInhMipetuu9OUvTWNnwNodzx+krlvAQIGjmECV+spyH/Ak3F5QDok+OoPXicip2HiJiWTuH6rQx6eh7BxlT0STH4xUbSUl6Df/xAIqaO9bBVn3taKUuy/ZAwYZImpvx4FYjVRgQzOec9r1vK0TmrldMiIDkO45ZXegxLLrRW13P0/heQHQ4CUhIYvfElNIHOtWaztNJ4qZQBqfFKLg3OMz135rNY624ClB0tHJcomTA5ZMGnANbaBmoOHPMy5hvZebNuLCoj71frXIN0i9pDJzj24IsIlUTCo7NI3/KyQg5ArfMleEyKBzmA6r1HO8eV+dSEySEB2G3yRpwZP1c2f+n1GjB07RIlcwNoKi7j3G839EhQF2cg6fmHmbznPRKevJ/GorIedV1wtLVzJesrV9WqQtoIHRfWjreSjwGar1ZRui3Ho7PfwHBGb3jRg6S1roGeoIuNJGBIPKV/zSF31irOrn4HXAu9B1zduhtLecelQxZZ9xTtrgC342Df8IwQyaYqBMKEWo0xaw1BI4d4DNJSWcfF32fRWnuD5NWPEDZ5lIe8NDuHq1v+ha2xGdkho4szYJg1hbj501EH6OgJ5oIS8hf/oWPm5HqNrE51vdt4nC/7k+9bIIT8GYA2Ipixn5jwjQrrZsju0XT5GubTRfiEBqFPisUvOrzPPi0VdeQ9YcJ63bWmxbzphTk7XHKvA/DrlJkfAU+Bcy2N+fA3vZK0WVoxny4idOKIfn+IO7lTz7zRObWCjdMv7VnhruOV9dws9F8u4CsAS1k1J54wYS4o6arWaaS8hvLP998yuZtnisl7wuROLkdjsKzqqtfL45FjB8gzwZnIJy6dS8Jjs3p8ausvHG3tXN26mytZO5W8Rcjsbg1Qze/X45ELHY9I7wHLXG26+CgSl8zFkDGh3zdkF2S7nep9PzhzmnK3FEGwUWOwrJr6zTdeL529EnRhf3LmfCHEBkBZiNrwIAwZkwi9a5Qzh9D6dNvXYW3jZkEJ9UdOOYPwdY/gXgdiufuGuC2C4Hy3kWXrOhmeBLQeA6jV6GLC8Y0KR613Hn+2phZaK69jqah1P/hdsCKLLIfGtnbG+f3eyfHtEHTh38mzom2SY4WQWQjE9tnBE+XIZKuQNrqCcH9wSwRdMGGSJiTnpatwTJOFMIKcgvPVX/kNIcM1gSgC8iTZfii3aEL+7fyG+C+6O8izl1GE5gAAAABJRU5ErkJggg==)](https://github.com/biopragmatics/bioregistry)
  ```

  If your README uses reStructuredText (.rst), use this instead:

  ```
  .. image:: https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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
      :target: https://github.com/biopragmatics/bioregistry
      :alt: Powered by the Bioregistry
  ```

  It looks like this:
  [![Powered by the Bioregistry](https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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)](https://github.com/biopragmatics/bioregistry)



  > [Unifying the identification of biomedical entities with the Bioregistry](https://bioregistry.io/doi:10.1038/s41597-022-01807-3) >
  > <br />Hoyt, C. T., Balk, M., Callahan, T. J., Domingo-Fernandez, D., Haendel,
  > M. A., Hegde, H. B., Himmelstein, D. S., Karis, K., Kunze, J., Lubiana, T.,
  > Matentzoglu, N., McMurry, J., Moxon, S., Mungall, C. J., Rutz, A., Unni, D.
  > R., Willighagen, E., Winston, D., and Gyori, B. M. (2022) <br />_Nature
  > Scientific Data_, s41597-022-01807-3

  ```bibtex
  @article{Hoyt2022Bioregistry,
      author = {Hoyt, Charles Tapley and Balk, Meghan and Callahan, Tiffany J and Domingo-Fern{\'{a}}ndez, Daniel and Haendel, Melissa A and Hegde, Harshad B and Himmelstein, Daniel S and Karis, Klas and Kunze, John and Lubiana, Tiago and Matentzoglu, Nicolas and McMurry, Julie and Moxon, Sierra and Mungall, Christopher J and Rutz, Adriano and Unni, Deepak R and Willighagen, Egon and Winston, Donald and Gyori, Benjamin M},
      doi = {10.1038/s41597-022-01807-3},
      issn = {2052-4463},
      journal = {Sci. Data},
      number = {1},
      pages = {714},
      title = {{Unifying the identification of biomedical entities with the Bioregistry}},
      url = {https://doi.org/10.1038/s41597-022-01807-3},
      volume = {9},
      year = {2022}
  }
  ```

  Talks on the Bioregistry:

  - [Future Curation in the Bioregistry](https://bit.ly/wpci2022-bioregistry-maintenance)
    (WPCI, December 2022)
  - [The Bioregistry - Governance and Review Team](https://bit.ly/wpci2022-bioregistry-governance)
    (WPCI, December 2022)
  - [Development, Maintenance, and Expansion of the Bioregistry](https://bit.ly/sorger-lab-bioregistry-2022)
    (Sorger Lab Meeting, October 2022)
  - [The Bioregistry, CURIEs, and OBO Community Health](https://bit.ly/icbo2022-cth)
    (ICBO 2022 (September))
  - [Introduction to the Bioregistry](https://bit.ly/bioregistry-short-talk)
    (Sorger Lab Meeting, July 2021)



  The Bioregistry was primarily developed by the
  [Gyori Lab for Computational Biomedicine](https://gyorilab.github.io) at
  Northeastern University, which was previously a part of the
  [Laboratory of Systems Pharmacology](https://hits.harvard.edu/the-program/laboratory-of-systems-pharmacology/about/)
  in the [Harvard Program in Therapeutic Science (HiTS)](https://hits.harvard.edu)
  at [Harvard Medical School](https://hms.harvard.edu/).



  1. Chan Zuckerberg Initiative (CZI) 2023-329850
  2. DARPA Automating Scientific Knowledge Extraction and Modeling (ASKEM)
     HR00112220036
  3. DARPA Young Faculty Award W911NF2010255 (PI: Benjamin M. Gyori).

rpm_license:
  MIT License  Copyright (c) 2020-2024 Charles Tapley Hoyt  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 988310c91b5730b1c7c70537f720ff398f50a10cf976c4a9034c202367731980
name: python-biorobot
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: The Bio-inspired Robotics Testbed (BRT).
url: https://github.com/Co-Evolve/brt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biorobot-0.3.4-1.src.rpm
checksum_type: sha256
description:
  <h1>
    <a href="#"><img alt="moojoco-banner" src=https://github.com/Co-Evolve/brt/blob/main/assets/banner.png?raw=true" width="100%"/></a>
  </h1>

  The **Bio-Inspired Robotics Testbed (BRT)** represents a significant stride in the convergence of robotics and
  experimental biology, offering a unique platform that leverages the MuJoCo physics simulator to create a collection of
  bio-inspired robotics simulation environments. This initiative is more than just a technical tool; it serves as a
  crucible for cross-disciplinary dialogue and innovation, uniting two fields that, while distinct, share a common goal of
  understanding and emulating complex biological systems. In the realm of robotics, this testbed addresses a pivotal
  challenge: the design and control of bio-inspired robots. These robots, inspired by the intricacies of biological
  organisms, present novel hurdles that contemporary optimization methodologies struggle to surmount. By providing a
  benchmark specifically tailored to these challenges, the initiative not only facilitates the validation of existing
  methodologies but also catalyzes the development of new approaches. This is crucial for advancing the field, as it
  pushes the boundaries of what we can achieve in robotic design and control, drawing inspiration from the most
  sophisticated systems found in nature. On the biological front, the application of robotics serves as a powerful
  comparative method. It offers a more controlled environment for conducting comparative studies, essential for dissecting
  complex behaviors, ecological interactions, and the evolutionary histories of organisms. This perspective is invaluable,
  as it transcends traditional observational methods, allowing for more controlled analyses. Overall, the Bio-Inspired
  Robotics Testbed is a testament to the symbiotic potential of robotics and biology. It not only advances our technical
  capabilities in creating machines that mimic life but also deepens our understanding of the biological phenomena that
  inspire these creations. This testbed is a stepping stone towards a future where the interplay between robotics and
  biology yields innovations that are as profound as they are transformative.

  BRT distinguishes itself with its capability to effortlessly simulate various
  morphological variations of bio-inspired robots. This flexibility is largely enabled by the use of the [Framework for
  Parameterized Robot Specifications (FPRS)](https://github.com/Co-Evolve/fprs), a framework that centralizes the
  adaptable definition of a robot's
  morphology. In FPRS, a 'Specification' acts as a comprehensive bundle, encapsulating all the modifiable parameters that
  define the robot's form and structure. This approach to morphology parameterization not only simplifies the modification
  process but also enhances the reproducibility and comparability of different morphological setups within the BRT

  The implementation of environments within the BRT adheres to framework defined in
  the [moojoco](https://github.com/Co-Evolve/moojoco) package.
  This framework defines an environment as a combination of a parameterized morphology, as defined by FPRS, and a
  configurable
  arena. Both the morphology and the arena in this context are essentially generators for MJCF (MuJoCo XML) files,
  allowing for dynamic and customizable environment creation. This design philosophy ensures that each environment within
  the BRT is both flexible and specific to the needs of the experiment at hand.

  In terms of simulation capabilities, the BRT offers environments in both native MuJoCo and MuJoCo XLA (MJX) formats.
  This dual availability caters to diverse computational needs and preferences, ensuring that researchers can select the
  simulation environment that best suits their specific requirements, whether it's the high-fidelity physics of native
  MuJoCo or the accelerated computation offered by MuJoCo XLA.

  In summary, the BRT's unique approach to morphology parameterization through FPRS, adherence to the moojoco
  framework for environment implementation, and availability in both MuJoCo and MJX formats, collectively contribute to
  its status as a versatile and powerful tool for bio-inspired robotics research. This tool not only facilitates a deeper
  exploration of robotic morphologies but also bridges the gap between theoretical research and practical application in
  the field of bio-inspired robotics.



  * [Brittle star](https://github.com/Co-Evolve/brt/blob/main/biorobot/brittle_star)



  Interested in having a model developed? Please fill in this [form](https://forms.gle/h1xgnZA39h2qhX8k9).



  Preliminary Jupyter Notebook examples can be found [here](https://github.com/Co-Evolve/SEL3-2024).



  ```pip install biorobot```


pkgId: 31f2eb477f2c4b344bfc34560371b9aecfb70605ff14759630133b43d4c407f2
name: python-biorosetta
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: A package to convert gene identifiers between different naming conventions
url: https://github.com/reemagit/biorosetta
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biorosetta-0.3.2-1.src.rpm
checksum_type: sha256
description:
  This is a package to map gene names between different naming conventions.

  Motivation: while there are popular packages for gene identifier mapping (e.g. ENSG, NCBI, HGNC) in the R environment (e.g. AnnotationDB), there is no standard solution in python.



  ```python
  import biorosetta as br
  ```

  - **Source-based system**: Instead of relying on a single repository for mapping gene identifiers, biorosetta integrates results from different repositories, or "sources". Biorosetta supports two types of sources under the same interface. (1) *Local sources*: biorosetta downloads a local version of the conversion tables from popular repositories (Ensembl Biomart, HGNC Biomart). Best option for highly reproducible gene conversion outputs that do not change over time (e.g. for scientific article preparation). (2) *Remote sources*: biorosetta interfaces to remote web service applications (MyGene) to convert gene names. Best option for highly up-to-date conversion.
  - **Priority system**: The user can specify an order of source priority, so that when different sources produce a different conversion output it is possible to define the most trusted result.
  - **Conversion report**: For critical gene mapping applications, biorosetta can optionally generate a report table that specifies the mapping output of each separate source and highlight where there have been mismatches between outputs, so that these mapping results can be investigated further.
  - **Multi-hits policies**: When multiple possible mapping outputs ("hits") are found, one can choose the policy for integrating them: "all": concatenates all the ID outputs with a pipe ("|") symbol (e.g. "foo|bar|baz"). "consensus": compares the output hits across different sources to select the ID that appears most frequently across different sources. E.g. if source A outputs "foo|bar" and source B outputs "bar|baz" then "bar" is selected as the final output.
  - **Gene name synonyms**: Gene symbols have many synonyms. When available within the source, biorosetta integrates the synonym information for one-way mapping from gene symbol to any other ID.
  - **Speed**: Biorosetta performs vectorized operations to achieve maximum efficiency.



  Sources:
  - Ensembl Biomart (https://useast.ensembl.org/biomart/martview): Local source
  - HGNC Biomart (GeneNames) (https://biomart.genenames.org/): Local source
  - MyGene (https://mygene.info): Remote source

  Gene Identifiers:

  - "ensg": Ensembl gene ID (all sources)
  - "entr": NCBI gene ID (entrezgene, all sources)
  - "symb": Gene name (symbol, all sources)
  - "ensp": Ensembl protein ID (ENSP, Ensembl Biomart only)
  - "hgnc": HGNC ID (Ensembl Biomart and HGNC Biomart only)



  See up-to-date documentation and examples at [github repo](https://github.com/reemagit/biorosetta).


pkgId: 2f52d055712f01f687c4fd9112e9906b16bd065ea7dacd84cb073c8502100c58
name: python-bios
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: bios is a library which helps you to read and write data to determined type of files.
url: https://github.com/bilgehannal/bios
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bios-0.1.2-1.src.rpm
checksum_type: sha256
description:
    - 'bios' is a python library which helps you for operations of I/O.
    - You can read determined type of files and assign the content of the files to the best suitable data type for these contents.
    - If it is required, developer should handle the exception handling issues.



  > pip install bios

      import bios


   - JSON Files
  	 - Can be assigned to data types of string, list or dict.
   - YAML Files
  	 - Can be assigned to data types of string, list or dict.
   - CSV Files
  	 - Can be assigned to data types of string or list.
   - Other Files
  	- Can be assigned to data type of string.




  You can read the file using read function of bios. If you will not give any file type, system can determined the file types showing in the below and assign the content of the files to suitable data_types.

      content1 = bios.read('file.txt')
      content2 = bios.read('file.json')
      content3 = bios.read('file.yaml')
      content4 = bios.read('file.csv')
      content4 = bios.read('file.csv', delimiter=';')
      content5 = bios.read('file.yml')
      content6 = bios.read('file')

  	
  	
  	

  - ##### Standart File

  You can read the content of a file and assign it into a string.

      content = bios.read('file.txt', file_type='standart')

  - ##### JSON File

  You can read the content of a JSON file and assign it into a dict or list object.

      content = bios.read('file.json', file_type='json')

  Type of the content could be 'list' or 'dict'
  - ##### YAML File

  You can read the content of a YAML file and assign it into a dict or list object.

      content = bios.read('file.yaml', file_type='yaml')
      content = bios.read('file.yaml', file_type='yml')

  Type of the content could be 'list' or 'dict'
  - ##### CSV File

  You can read the content of a CSV file and assign it into a list. Default delimiter is comma ' , '.

      content = bios.read('file.json', file_type='csv')
  	content = bios.read('file.json', file_type='csv', delimiter=';')

  Type of the content could be 'list'


  You can write your 'data' object to a file. If you will not give a specific file a file type, file type is determined according to the file name.

      bios.write('file.txt', data1)
      bios.write('file.json', data2)
      bios.write('file.yaml', data3)
      bios.write('file.csv', data4)
      bios.write('file.csv', data4, delimiter=';')
      bios.write('file.yml', data5)
      bios.write('file', data5)

  	
  	
  	

  - ##### Standart File

  You can write a string object to any file giving a file type as 'standart'

       bios.write('file.txt', data, file_type='standart')

  - ##### JSON File

  You can write a list or dict object to any file giving a file type as 'json'

       bios.write('file.json', data, file_type='json')

  - ##### YAML File

  You can write a list or dict object to any file giving a file type as 'yaml' or 'yml'

       bios.write('file.yml', data, file_type='yaml')

  - ##### CSV File

  You can write a list object to any file giving a file type as 'standart'

       bios.write('file.csv', data, file_type='csv')
       bios.write('file.csv', data, file_type='csv', delimiter=';')

  You can use the parameter of 'delimiter' for separating the contents from each other.


  You can append or add a content to an existing file. This function is available for only text files or csv files.

      bios.append('file.txt', data)
      bios.append('file.txt', data, line=2)
      bios.append('file.txt', data, delimiter=';')
      bios.append('file.csv', data, line=2, delimiter=';')

  Line is assumed that starting from the value of 1

  - ##### Standart File

  You can append a string object to a existing or nonexistent file. If you don't give a line parameter, bios would append the content after the end of the file.

       bios.append('file.txt', data, file_type='standart')
       bios.append('file.txt', data, file_type='standart', line=2)

  - ##### CSV File

  You can append a list object to a existing or nonexistent file. If you don't give a line parameter, bios would append the content after the end of the file.

       bios.append('file.csv', data, file_type='csv')
       bios.append('file.csv', data, file_type='csv', line=2)



      import bios
      content = bios.read('files/my_file.csv')
      second_row = content[1]
      for single_column in second_row:
  	    print(single_column)


pkgId: 191505cc9c4cb966efb939a188511a5cce33984767be62198ffbe104fe82c43d
name: python-bioscan-dataset
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: PyTorch torchvision-style datasets for BIOSCAN-1M and BIOSCAN-5M.
url: https://github.com/bioscan-ml/dataset
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioscan-dataset-1.0.0-1.src.rpm
checksum_type: sha256
description:
  In this package, we provide PyTorch/torchvision style dataset classes to load the `BIOSCAN-1M <BS1M-paper_>`_ and `BIOSCAN-5M <BS5M-paper_>`_ datasets.
  BIOSCAN-1M and 5M are large multimodal datasets for insect biodiversity monitoring, containing over 1 million and 5 million specimens, respectively.
  The datasets are comprised of RGB microscopy images, DNA barcodes, and fine-grained, hierarchical taxonomic labels.
  Every sample has both an image and a DNA barcode, but the taxonomic labels are incomplete and only extend all the way to the species level for around 9% of the specimens.


pkgId: bf868cfd6c47491723506907cab68b0f58cd6976b7e0afbab57a3e02f37b7b55
name: python-bioscan-dataset
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: PyTorch torchvision-style datasets for BIOSCAN-1M and BIOSCAN-5M.
url: https://github.com/bioscan-ml/dataset
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioscan-dataset-1.0.1-1.src.rpm
checksum_type: sha256
description:
  +------------------+----------------------------------------------------------------------+
  | Latest Release   | |PyPI badge|                                                         |
  +------------------+----------------------------------------------------------------------+
  | License          | |License|                                                            |
  +------------------+----------------------------------------------------------------------+
  | Documentation    | |Documentation|                                                      |
  +------------------+----------------------------------------------------------------------+
  | Code style       | |black| |pre-commit|                                                 |
  +------------------+----------------------------------------------------------------------+
  | Citation         | |DOI badge|                                                          |
  +------------------+----------------------------------------------------------------------+
  In this package, we provide PyTorch/torchvision style dataset classes to load the `BIOSCAN-1M <BS1M-paper_>`_ and `BIOSCAN-5M <BS5M-paper_>`_ datasets.
  BIOSCAN-1M and 5M are large multimodal datasets for insect biodiversity monitoring, containing over 1 million and 5 million specimens, respectively.
  The datasets are comprised of RGB microscopy images, DNA barcodes, and fine-grained, hierarchical taxonomic labels.
  Every sample has both an image and a DNA barcode, but the taxonomic labels are incomplete and only extend all the way to the species level for around 9% of the specimens.
  Documentation, including the full API details, is available online at readthedocs_.


pkgId: 9a16e616f42aaa588e8ffa0dc84b8a787b66784f74938fef4ffa7e82fbe0a5fc
name: python-bioservices
arch: src
version: 1.11.2
epoch: 0
release: 1
summary: Access to Biological Web Services from Python
url: http://github.com/cokelaer/bioservices
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioservices-1.11.2-1.src.rpm
checksum_type: sha256
description:
  Maintaining BioServices would not have been possible without users and contributors.
  Each contribution has been an encouragement to pursue this project. Thanks to all:


pkgId: 7c45864373cc8943a548c09f15b8fbab169dbd0ccbbeaabbc9fa2c50b79baa6d
name: python-biosets
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Bioinformatics datasets and tools
url: https://github.com/psmyth94/biosets
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosets-1.2.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      $${\Huge{\textbf{\textsf{\color{#2E8B57}Bio\color{#4682B4}sets}}}}$$
      <br/>
      <br/>
  </p>
  <p align="center">
      <a href="https://github.com/psmyth94/biosets/actions/workflows/ci_cd_pipeline.yml?query=branch%3Amain"><img alt="Build" src="https://github.com/psmyth94/biosets/actions/workflows/ci_cd_pipeline.yml/badge.svg?branch=main"></a>
      <a href="https://github.com/psmyth94/biosets/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/psmyth94/biosets.svg?color=blue"></a>
      <a href="https://github.com/psmyth94/biosets/tree/main/docs"><img alt="Documentation" src="https://img.shields.io/website/http/github/psmyth94/biosets/tree/main/docs.svg?down_color=red&down_message=offline&up_message=online"></a>
      <a href="https://github.com/psmyth94/biosets/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/psmyth94/biosets.svg"></a>
      <a href="CODE_OF_CONDUCT.md"><img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg"></a>
      <a href="https://zenodo.org/records/14028772"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.14028772.svg" alt="DOI"></a>
  </p>

  **Biosets** is a specialized library that extends 🤗 [Datasets](https://github.com/huggingface/datasets) for bioinformatics data, providing the following main features:

  - **Bioinformatics Specialization**: Streamlines data management specific to bioinformatics, such as handling samples, features, batches, and associated metadata.
  - **Automatic Column Detection**: Infers sample, batch, input features, and target columns, simplifying downstream preprocessing.
  - **Custom Data Classes**: Leverages specialized data classes (`ValueWithMetadata`, `Sample`, `Batch`, `RegressionTarget`, etc.) to manage metadata-rich bioinformatics data.
  - **Polars Integration**: Optional [Polars](https://github.com/pola-rs/polars) integration enables high-performance data manipulation, ideal for large datasets.
  - **Flexible Task Support**: Native support for binary classification, multiclass classification, multiclass-to-binary classification, and regression, adapting to diverse bioinformatics tasks.
  - **Integration with 🤗 Datasets**: `load_dataset` function supports loading various bioinformatics formats like CSV, JSON, NPZ, and more, including metadata integration.
  - **Arrow File Caching**: Uses [Apache Arrow](https://github.com/apache/arrow) for efficient on-disk caching, enabling fast access to large datasets without memory limitations.

  Biosets helps bioinformatics researchers focus on analysis rather than data handling, with seamless compatibility with 🤗 Datasets.





  You can install **Biosets** from PyPI:

  ```bash
  pip install biosets
  ```



  Install **Biosets** via conda:

  ```bash
  conda install -c patrico49 biosets
  ```



  **Biosets** provides a straightforward API for handling bioinformatics datasets with integrated metadata management. Here's a quick example:

  ```python
  from biosets import load_biodata

  bio_data = load_dataset(
      data_files="data_with_samples.csv",
      sample_metadata_files="sample_metadata.csv",
      feature_metadata_files="feature_metadata.csv",
      target_column="metadata1",
      experiment_type="metagenomics",
      batch_column="batch",
      sample_column="sample",
      metadata_columns=["metadata1", "metadata2"],
      drop_samples=False
  )["train"]
  ```

  For further details, check the [advance usage documentation](./docs/DATA_LOADING.md).



  - **Bioinformatics Focus**: While 🤗 Datasets is a general-purpose library, Biosets is tailored for the bioinformatics domain.
  - **Seamless Metadata Integration**: Biosets is built for datasets with metadata dependencies, like sample and feature metadata.
  - **Automatic Column Detection**: Reduces preprocessing time with automatic inference of sample, batch, feature, and label columns.
  - **Specialized Data Classes**: Biosets introduces custom classes (e.g., `Sample`, `Batch`, `ValueWithMetadata`) to enable richer data representation.



  Biosets may run Python code from custom `datasets` scripts to handle specific data formats. For security, users should:

  - Inspect dataset scripts prior to execution.
  - Use pinned versions for any repository dependencies.

  If you manage a dataset and wish to update or remove it, please open a discussion or pull request on the Community tab of 🤗's datasets page.



  If you'd like to cite **Biosets**, please use the following:

  ```bibtex
  @misc{smyth2024biosets,
      title = {psmyth94/biosets: 1.1.0},
      author = {Patrick Smyth},
      year = {2024},
      url = {https://github.com/psmyth94/biosets},
      note = {A library designed to support bioinformatics data with custom features, metadata integration, and compatibility with 🤗 Datasets.}
  }
  ```


pkgId: df4166a1f062d9ccc5eca68948f9c03386f18da1d0eba50004b22bbbe46d6971
name: python-biosignal-device-interface
arch: src
version: 0.1.311
epoch: 0
release: 1
url: https://pypi.org/project/biosignal-device-interface/
rpm_license: CC BY-SA 4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosignal-device-interface-0.1.311-1.src.rpm
checksum_type: sha256
summary:
  Python communication interface to many biosignal devices manufactured by several companies to easy integration in custom PySide6 applications.

description:
  <!-- PROJECT LOGO -->
  <br />
  <div align="center">
    <a href="https://github.com/NsquaredLab/Biosignal-Device-Interface">
      <img src="images/logo.png" alt="Logo" width="80" height="80">
    </a>

  <h3 align="center">Biosignal Device Interface</h3>

    <p align="center">
      Python communication interface to many biosignal devices manufactured by several companies to easy integration in custom PySide6 applications.
      <br />
      <a href="https://nsquaredlab.github.io/Biosignal-Device-Interface/"><strong>Explore the docs »</strong></a>
    </p>
  </div>



  <!-- TABLE OF CONTENTS -->
  <details>
    <summary>Table of Contents</summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
      </li>
      <li><a href="#contact">Contact</a></li>
      <li>
        <a href="#getting-started">Getting Started</a>
        <ul>
          <li><a href="#development-installation">Development Installation</a></li>
          <li><a href="#package-installation">Package Installation</a></li>
        </ul>
      </li>
      <li><a href="#usage">Usage</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#acknowledgments">Acknowledgments</a></li>
    </ol>
  </details>




  Give a brief introduction into the project.

  <!-- CONTACT -->


   [Dominik I. Braun](https://www.nsquared.tf.fau.de/person/dominik-braun/) - dome.braun@fau.de

  Project Link: [https://github.com/NsquaredLab/Biosignal-Device-Interface](https://github.com/NsquaredLab/Biosignal-Device-Interface)


  <!-- GETTING STARTED -->


  The local set up is made using [Poetry](https://python-poetry.org/). You can install Poetry using the following command.
  Note: It is recommeded to install it globally.
  ```bash
  pip install poetry
  ```

  Then, you can install the dependencies in your work area using the following command:
  ```bash
  poetry install
  ```


  If you want to contribute to the project, you can install the development dependencies using the following command:
  ```bash
  poetry install --with dev,docs
  ```


  Poetry
  ```Bash
  poetry add git+https://github.com/NsquaredLab/Biosignal-Device-Interface.git
  ```

  PIP
  ```sh
  pip install git+https://github.com/NsquaredLab/Biosignal-Device-Interface.git
  ```


  <!-- USAGE EXAMPLES -->


  Examples of how you can use this package can be found in our [examples gallery](https://nsquaredlab.github.io/Biosignal-Device-Interface/auto_examples/index.html).


  <!-- LICENSE -->


  Distributed under the CC BY-SA 4.0 License. See `LICENSE.txt` for more information.

  <!-- ACKNOWLEDGMENTS -->

  * Find available Python and Matlab implementations of OT Bioelettronica's devices on their [website](https://otbioelettronica.it/en/download/).
  <br>
  Note: The example scripts does not provide you with the same level of utility for GUI implementations.

  <p align="right">(<a href="#readme-top">back to top</a>)</p>


pkgId: 07e6947e4e858a63a871b52f1f82ab3a7b21dc59d387924f3f79897b22d61336
name: python-biosimulators-copasi
arch: src
version: 0.2.22
epoch: 0
release: 1
url: https://basico.readthedocs.io/en/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosimulators-copasi-0.2.22-1.src.rpm
checksum_type: sha256
summary:
  BioSimulators-compliant command-line interface to the COPASI simulation program <http://copasi.org>.

description:
  [![Latest release](https://img.shields.io/github/v/tag/biosimulators/Biosimulators_COPASI)](https://github.com/biosimulations/Biosimulators_COPASI/releases)
  [![PyPI](https://img.shields.io/pypi/v/biosimulators_copasi)](https://pypi.org/project/biosimulators_copasi/)
  [![CI status](https://github.com/biosimulators/Biosimulators_COPASI/workflows/Continuous%20integration/badge.svg)](https://github.com/biosimulators/Biosimulators_COPASI/actions?query=workflow%3A%22Continuous+integration%22)
  [![Test coverage](https://codecov.io/gh/biosimulators/Biosimulators_COPASI/branch/dev/graph/badge.svg)](https://codecov.io/gh/biosimulators/Biosimulators_COPASI)
  [![All Contributors](https://img.shields.io/github/all-contributors/biosimulators/Biosimulators_COPASI/HEAD)](#contributors-)



  BioSimulators-compliant command-line interface and Docker image for the [COPASI](http://copasi.org/) simulation program.

  This command-line interface and Docker image enable users to use COPASI to execute [COMBINE/OMEX archives](https://combinearchive.org/) that describe one or more simulation experiments (in [SED-ML format](https://sed-ml.org)) of one or more models (in [SBML format](http://sbml.org])).

  A list of the algorithms and algorithm parameters supported by COPASI is available at [BioSimulators](https://biosimulators.org/simulators/copasi).

  A simple web application and web service for using COPASI to execute COMBINE/OMEX archives is also available at [runBioSimulations](https://run.biosimulations.org).




  ```
  pip install biosimulators-copasi
  ```


  ```
  docker pull ghcr.io/biosimulators/copasi
  ```




  ```
  usage: biosimulators-copasi [-h] [-d] [-q] -i ARCHIVE [-o OUT_DIR] [-v]

  BioSimulators-compliant command-line interface to the COPASI simulation program <http://copasi.org>.

  optional arguments:
    -h, --help            show this help message and exit
    -d, --debug           full application debug mode
    -q, --quiet           suppress all console output
    -i ARCHIVE, --archive ARCHIVE
                          Path to OMEX file which contains one or more SED-ML-
                          encoded simulation experiments
    -o OUT_DIR, --out-dir OUT_DIR
                          Directory to save outputs
    -v, --version         show program's version number and exit
  ```


  The entrypoint to the Docker image supports the same command-line interface described above.

  For example, the following command could be used to use the Docker image to execute the COMBINE/OMEX archive `./modeling-study.omex` and save its outputs to `./`.

  ```
  docker run \
    --tty \
    --rm \
    --mount type=bind,source="$(pwd)",target=/root/in,readonly \
    --mount type=bind,source="$(pwd)",target=/root/out \
    ghcr.io/biosimulators/copasi:latest \
      -i /root/in/modeling-study.omex \
      -o /root/out
  ```


  Documentation is available at https://docs.biosimulators.org/Biosimulators_COPASI/.


  This package is released under the [MIT license](LICENSE). COPASI is released under the [Artistic 2.0 License](http://copasi.org/Download/License/).


  This package was developed by the [Center for Reproducible Biomedical Modeling](http://reproduciblebiomodels.org). COPASI was developed by a [team](http://copasi.org/About/Team/) at the University of Connecticut, the University of Heidelberg, and the University of Virginia with assistance from the contributors listed [here](CONTRIBUTORS.md).


  Please contact the [BioSimulators Team](mailto:info@biosimulators.org) with any questions or comments.


pkgId: f0475a11e7bc4f385f2667c0525351ef695b1abf243c7e53483dab5ad01dc79c
name: python-biosimulators-pysces
arch: src
version: 0.1.33
epoch: 0
release: 1
url: https://github.com/biosimulators/Biosimulators_PySCeS>
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosimulators-pysces-0.1.33-1.src.rpm
checksum_type: sha256
summary:
  BioSimulators-compliant command-line interface to the PySCeS simulation program <http://pysces.sourceforge.net/>.

description:
  BioSimulators-compliant command-line interface to the
  `PySCeS <http://pysces.sourceforge.net/>`__ simulation program.
  This command-line interface and Docker image enable users to use PySCeS
  to execute `COMBINE/OMEX archives <https://combinearchive.org/>`__ that
  describe one or more simulation experiments (in `SED-ML
  format <https://sed-ml.org>`__) of one or more models (in `SBML
  format <http://sbml.org]>`__).
  A list of the algorithms and algorithm parameters supported by PySCeS is
  available at
  `BioSimulators <https://biosimulators.org/simulators/pysces>`__.
  A simple web application and web service for using PySCeS to execute
  COMBINE/OMEX archives is also available at
  `runBioSimulations <https://run.biosimulations.org>`__.


pkgId: 7d9a9db9452d8495564696da22e13d89141eca173aca83f2190d386b0b05e0cc
name: python-biosimulators-simularium
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: Converting Biosimulators spatial simulation outputs into a Simularium-compliant format.
url: https://pypi.org/project/biosimulators-simularium/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosimulators-simularium-0.6.3-1.src.rpm
checksum_type: sha256
description:
  Converting Biosimulators spatial simulation outputs into a Simularium-compliant format.


  *PLEASE NOTE:*
  If you are using Apple silicon or Windows, you MUST use the Building from Source installation. Currently, smoldyn is only
  available on PyPI cleanly on Linux.




  The easiest way to interact with `Biosimulators_simularium` is via the Python Package Index and a
  [virtual environment](https://docs.python.org/3/tutorial/venv.html).

     1. `poetry use python3.10`
  2.
  We recommend [installing and using Conda](https://conda.io/projects/conda/en/latest/user-guide/concepts/environments.html):

     After you have created the environment...

     1. `conda create -n biosimularium python=3.10`
     2. `conda activate biosimularium`
     3. `pip install biosimulators-simularium`

     To verify successful platform installation...

     1. `python3`
     2. `import biosimulators_simularium as biosimularium`
     3. `biosimularium.__version__` should display the most recent version with no errors.


  The preferred build-from-source method involves using Python Poetry. Please ensure that this
  is globally installed on your machine. The preferred method of installation from source
  is through the use of the `install-deps.sh` script that is included at the root of this
  repo. Follow the instructions below to install the environment on your machine (mac):

  1. `git clone https://github.com/biosimulators/biosimulators-simularium.git`
  2. `cd Biosimulators_simularium`
  3. `chmod +x ./install.sh`
  4. `./install.sh`
  5. OPTIONAL: `poetry shell`
  6. `python3`
  7. `import biosimulators_simularium`

  If there are no errors, you are all set!





  1. Set up a virtual environment. We recommend using Conda: `conda create -n biosimularium
  python=3.10`

  2. `conda activate biosimularium`

  3. `cd {REPO DESTINATION}`

  4. `git clone https://github.com/biosimulators/biosimulators-simularium.git`

  5. `cd Biosimulators_simularium`

  6. `pip install -e .`

  7. FOR MAC ONLY: Download Smoldyn for your Mac (Silicon or Intel): https://www.smoldyn.org/download.html
     - `cd /path/to/your/download/of/smoldyn-2.72-mac`
     - `sudo -H ./install.sh`

  8. OTHERWISE: `pip install smoldyn`


  A Jupyter Notebook will soon be available which is based off of the simulariumio tutorial series. This will
  give users the ability to have a tool that quickly generates simularium files with the click of a button based
  on a valid COMBINE/OMEX archive.






  1. Defining the filepath to an unpacked directory/archive in which a Smoldyn model resides
     and defining the name of simularium file. We also want to save the simularium file in JSON format:
  ```python
  from biosimulators_simularium import generate_simularium_file


  archive_root = 'biosimulators_simularium/tests/fixtures/archives/MinE'
  simularium_fn = 'simulation'
  is_json = True
  ```
  2. Generating a simularium file from the model file housed in the `archive_root`:
  ```python
  generate_simularium_file(
     working_dir=archive_root,
     simularium_filename=simularium_fn,
     use_json=is_json
  )

  import os

  assert os.path.exists(os.path.join(archive_root, simularium_fn)))
  ```


  ```python
  """Generating a simularium file for the MinE Smoldyn model."""

  import os
  from biosimulators_simularium import generate_simularium_file


  working_dir = 'biosimulators_simularium/tests/fixtures/crowding'


  simularium_fn = os.path.join(working_dir, 'simplified-api-output')


  model_fp = os.path.join(working_dir, 'model.txt')


  red_molecular_mass = 11004
  green_molecular_mass = 12424


  agent_params = {
      'red': {
          'density': 1.0,
          'molecular_mass': red_molecular_mass,
      },
      'green': {
          'density': 1.0,
          'molecular_mass': green_molecular_mass,
      }
  }


  generate_simularium_file(
      working_dir=working_dir,
      simularium_filename=simularium_fn,
      agent_params=agent_params,
      model_fp=model_fp
  )


  try:
      assert os.path.exists(simularium_fn)
      print(f'{simularium_fn} has been successfully generated.')
  except:
      AssertionError('A simularium file could not be generated.')
  ```

  Consider also this MinE simulation where we use the params function to extract parameters of agents from the Smoldyn model file:

  ```python
  import os
  from biosimulators_simularium.simulation_data import generate_agent_params_for_minE
  from biosimulators_simularium.exec import generate_simularium_file

  working_dir = 'biosimulators_simularium/tests/fixtures/MinE'


  simularium_fn = os.path.join(working_dir, 'simplified-api-output')

  model_fp = os.path.join(working_dir, 'model.txt')

  base_mass = 12100
  density = 1.0
  agent_params = generate_agent_params_for_minE(model_fp, base_mass, density)

  generate_simularium_file(
      working_dir=working_dir,
      simularium_filename=simularium_fn,
      agent_params=agent_params,
      model_fp=model_fp
  )

  try:
      assert os.path.exists(simularium_fn)
      print(f'{simularium_fn} has been successfully generated.')
  except:
      AssertionError('A simularium file could not be generated.')
  ```

  You may then navigate to https://simularium.allencell.org/viewer and drag/drop the newly generated simularium
  file into the GUI window.




     To report an issue, please visit [our Github issues page](https://github.com/biosimulators/Biosimulators_simularium/issues).

     To contact us, please send an email to apatrie@uchc.edu or info@biosimulators.org


pkgId: 1de4e9688892ac6599be1cc3766760c695cda04d90db7d9a29089bcde64dfc37
name: python-biosimulators-utils
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: description
url: https://github.com/biosimulators/Biosimulators_utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosimulators-utils-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Latest release](https://img.shields.io/github/v/release/biosimulators/Biosimulators_utils)](https://github.com/biosimulators/Biosimulators_utils/releases)
  [![PyPI](https://img.shields.io/pypi/v/biosimulators-utils)](https://pypi.org/project/biosimulators-utils/)
  [![CI status](https://github.com/biosimulators/Biosimulators_utils/workflows/Continuous%20integration/badge.svg)](https://github.com/biosimulators/Biosimulators_utils/actions?query=workflow%3A%22Continuous+integration%22)
  [![Test coverage](https://codecov.io/gh/biosimulators/Biosimulators_utils/branch/dev/graph/badge.svg)](https://codecov.io/gh/biosimulators/Biosimulators_utils)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://tutorial.biosimulators.org/)
  [![All Contributors](https://img.shields.io/github/all-contributors/biosimulators/Biosimulators_utils/HEAD)](#contributors-)


  Command-line application and high-level utilities for reading, writing, validating, and executing [COMBINE/OMEX format](https://combinearchive.org/) files that contain descriptions of simulations in [Simulation Experiment Description Markup Language](https://sed-ml.org/) (SED-ML) format with models in formats such as the [BioNetGen Language](https://bionetgen.org) (BNGL) and the [Systems Biology Markup Language](http://sbml.org) (SBML).




  * Python >= 3.7
  * pip (latest)



  * [Docker](https://www.docker.com/): required to execute containerized simulation tools
  * [Java](https://www.java.com/): required to parse and validate NeuroML/LEMS files
  * [Perl](https://www.perl.org/): required to parse and validate BioNetGen files
  * [RBApy](https://sysbioinra.github.io/RBApy/): required to parse and validate RBA files
  * [XPP](http://www.math.pitt.edu/~bard/xpp/xpp.html): required to parse and validate XPP files


  ```
  pip install biosimulators-utils
  ```


  ```
  pip install git+https://github.com/biosimulators/Biosimulators_utils.git#biosimulators_utils
  ```



  To use BioSimulators utils to validate BNGL models, install BioSimulators utils with the `bgnl` option:
  ```
  pip install biosimulators-utils[bgnl]
  ```

  To use BioSimulators utils to validate CellML models, install BioSimulators utils with the `cellml` option:
  ```
  pip install biosimulators-utils[cellml]
  ```

  To use BioSimulators utils to validate LEMS models, install [Java](https://www.java.com/) and then install BioSimulators utils with the `lems` option:
  ```
  pip install biosimulators-utils[lems]
  ```

  To use BioSimulators utils to validate NeuroML models, install BioSimulators utils with the `neuroml` option:
  ```
  pip install biosimulators-utils[neuroml]
  ```

  To use BioSimulators utils to validate SBML models, install BioSimulators utils with the `sbml` option:
  ```
  pip install biosimulators-utils[sbml]
  ```

  To use BioSimulators utils to validate SBML models, install BioSimulators utils with the `smoldyn` option:
  ```
  pip install biosimulators-utils[smoldyn]
  ```

  To use BioSimulators utils to convert Escher metabolic maps to Vega flux data visualizations, install BioSimulators utils with the `escher` option:
  ```
  pip install biosimulators-utils[escher]
  ```

  To use BioSimulators utils to execute containerized simulation tools, install BioSimulators utils with the `containers` option:
  ```
  pip install biosimulators-utils[containers]
  ```

  To use BioSimulators utils to log the standard output and error produced by simulation tools, install BioSimulators utils with the `logging` option:
  ```
  pip install biosimulators-utils[logging]
  ```



  This package is available in the `ghcr.io/biosimulators/biosimulators` Docker image. This image includes all of the optional dependencies and installation options.

  To install and run this image, run the following commands:
  ```
  docker pull ghcr.io/biosimulators/biosimulators
  docker run -it --rm ghcr.io/biosimulators/biosimulators
  ```

  This image includes this package, as well as standardized Python APIs for the simulation tools validated by BioSimulators. Because this image aims to incorporate as many simulation tools as possible within a single Python environment, this image may sometimes lag behind the latest version of this package.

  The Dockerfile for this image is available [here](https://github.com/biosimulators/Biosimulators/blob/dev/Dockerfile).




  A tutorial for the command-line interface is available [here](https://docs.biosimulators.org/Biosimulators_utils/).


  Interactive tutorials for using BioSimulators-utils and Python APIs for simulation tools to execute simulations are available online from Binder [here](https://tutorial.biosimulators.org/). The Jupyter notebooks for these tutorials are also available [here](https://github.com/biosimulators/Biosimulators_tutorials).


  API documentation is available [here](https://docs.biosimulators.org/Biosimulators_utils/).


  This package is released under the [MIT license](LICENSE).


  This package was developed by the [Karr Lab](https://www.karrlab.org) at the Icahn School of Medicine at Mount Sinai in New York and the [Center for Reproducible Biomedical Modeling](http://reproduciblebiomodels.org) with assistance from the contributors listed [here](CONTRIBUTORS.md).


  We enthusiastically welcome contributions to BioSimulators utils! Please see the [guide to contributing](CONTRIBUTING.md) and the [developer's code of conduct](CODE_OF_CONDUCT.md).


  This work was supported by National Institutes of Health award P41EB023912.


  Please contact the [BioSimulators Team](mailto:info@biosimulators.org) with any questions or comments.


pkgId: f955ab1ecde68830732c45cf8a9e53cea57b573cb3ba19314111c7a68a944bd9
name: python-biosppy
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: A toolbox for biosignal processing written in Python.
url: https://github.com/scientisst/BioSPPy
rpm_license: BSD 3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosppy-2.2.2-1.src.rpm
checksum_type: sha256
description:
  <a href="https://biosppy.readthedocs.org/">
  <picture>
    <source media="(prefers-color-scheme: light)" srcset="docs/logo/logo_400.png">
    <source media="(prefers-color-scheme: dark)" srcset="docs/logo/logo_inverted_400.png">
    <img alt="Image" title="I know you're listening! - xkcd.com/525">
  </picture>
  </a>

  *A toolbox for biosignal processing written in Python.*

  [![PyPI version](https://badgen.net/pypi/v/biosppy)](https://pypi.org/project/biosppy/)
  [![PyPI downloads](https://badgen.net/pypi/dm/biosppy/?color=blue)](https://pypi.org/project/biosppy/)
  [![License](https://badgen.net/pypi/license/biosppy?color=grey)](https://github.com/scientisst/BioSPPy/blob/main/LICENSE)

  [![GitHub stars](https://badgen.net/github/stars/scientisst/BioSPPy?color=yellow)]()
  [![GitHub issues](https://badgen.net/github/open-issues/scientisst/BioSPPy?color=cyan)](https://github.com/scientisst/BioSPPy/issues)



  ```
  🌀 New module for signal quality assessment 🌀
  With the biosppy.quality module you can now evaluate the quality of your signals!
  So far, the EDA and ECG quality are available, but more could be added soon.
  ```
  ```
  🫀 New module for heart rate variability (biosppy.signals.hrv)
  🎊 New module for feature extraction (biosppy.features)
  ```



  The toolbox bundles together various signal processing and pattern recognition
  methods geared towards the analysis of biosignals.

  Highlights:

  - Support for various biosignals: ECG, EDA, EEG, EMG, PCG, PPG, Respiration, HRV
  - Signal analysis primitives: filtering, frequency analysis
  - Feature extraction: time, frequency, and non-linear domain
  - Signal quality assessment
  - Signal synthesizers
  - Clustering
  - Biometrics

  Documentation can be found at: <https://biosppy.readthedocs.org/>



  Installation can be easily done with `pip`:

  ```bash
  $ pip install biosppy
  ```

  Alternatively, you can install the latest version from the GitHub repository:

  ```bash
  $ pip install git+https://github.com/scientisst/BioSPPy.git
  ```



  The code below loads an ECG signal from the `examples` folder, filters it,
  performs R-peak detection, and computes the instantaneous heart rate.

  ```python
  from biosppy import storage
  from biosppy.signals import ecg


  signal, mdata = storage.load_txt('./examples/ecg.txt')


  out = ecg.ecg(signal=signal, sampling_rate=1000., show=True)
  ```

  This should produce a plot similar to the one below.

  ![ECG summary example](docs/images/ECG_summary.png)



  - bidict
  - h5py
  - matplotlib
  - numpy
  - scikit-learn
  - scipy
  - shortuuid
  - six
  - joblib


  Please use the following if you need to cite BioSPPy:

  P. Bota, R. Silva, C. Carreiras, A. Fred, and H. P. da Silva, "BioSPPy: A Python toolbox for physiological signal processing," SoftwareX, vol. 26, pp. 101712, 2024, doi: 10.1016/j.softx.2024.101712.

  ```latex
  @article{biosppy,
      title = {BioSPPy: A Python toolbox for physiological signal processing},
      author = {Patrícia Bota and Rafael Silva and Carlos Carreiras and Ana Fred and Hugo Plácido {da Silva}},
      journal = {SoftwareX},
      volume = {26},
      pages = {101712},
      year = {2024},
      issn = {2352-7110},
      doi = {https://doi.org/10.1016/j.softx.2024.101712},
      url = {https://www.sciencedirect.com/science/article/pii/S2352711024000839},
  }
  ```

  However, if you want to cite a specific version of BioSPPy, you can use Zenodo's DOI:

  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11048615.svg)](https://doi.org/10.5281/zenodo.11048615)



  BioSPPy is released under the BSD 3-clause license. See LICENSE for more details.



  This program is distributed in the hope it will be useful and provided
  to you "as is", but WITHOUT ANY WARRANTY, without even the implied
  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. This
  program is NOT intended for medical diagnosis. We expressly disclaim any
  liability whatsoever for any direct, indirect, consequential, incidental
  or special damages, including, without limitation, lost revenues, lost
  profits, losses resulting from business interruption or loss of data,
  regardless of the form of action or legal theory under which the
  liability may be asserted, even if advised of the possibility of such
  damages.


pkgId: a946bd3a0f2f463f5fba4913bc6e629e60b64249a3d468fe5b638e8a8788e781
name: python-biostarPython
arch: src
version: 0.4.0.2
epoch: 0
release: 1
summary: Python client for Suprema GSDK with included callable classes.
url: https://github.com/gcartlidge/biostarPython
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biostarPython-0.4.0.2-1.src.rpm
checksum_type: sha256
description:
  This is the pip distributable version of the Suprema GSDK Python client, which makes it easier to interact with the GSDK.<br>

  The examples from the [Suprema GSDK Wiki](https://supremainc.github.io/g-sdk/) can be used, but with this package, all dependencies are handled via PIP. The EventCode .json file and device list are also initialized automatically when importing package.<br>

  On some clients (Particularly android) the  EventCode json can sometimes not be loaded. If this happens, an error will display. You can then call

  ```python
  JsonFileLocation = "C:\\biostarPython\\event_code.json"
  biostarPython.initCodeMap(JsonFileLocation)
  ```
  To check Event codes, call
  ```python
  biostarPython.getEventString(eventCode,subCode)
  ```
  To check device type, call
  ```python
  biostarPython.deviceType[deviceCode]
  ```
  I'd also recommend checking out [Advanced Installer](https://www.advancedinstaller.com/)! They allow free licences for open-source projects and the features of the program licences are well worth it!



  All classes that can be used are imported under the biostarPython package.
  The ones currently written are:<br>
  **GatewayClient, ConnectSvc, DeviceSvc, FaceSvc, FingerSvc, StatusSvc, UserSvc, DisplaySvc, AdminSvc, WiegandSvc, TimeSvc, CardSvc, EventSvc, NetworkSvc, ServerSvc, SystemSvc, DoorSvc, RS485Svc, AuthSvc, AccessSvc, ScheduleSvc, ActionSvc, TNASvc, OperatorSvc, LockZoneSvc, TimedAPBZoneSvc, APBZoneSvc, IntrusionZoneSvc, FireZoneSvc, InterlockZoneSvc, UDPSvc & TestSvc**

  With the remaining being added in a future release.
  I think im up to date! <br>

  With all of these services, they are a callable class underneath the biostarPython package. An example of initial setup with the GatewayClient and ConnectSvc is below:
  For all of the functions below these services, they are formated with the first letter in lowercase, so to search a device would be searchDevice(), to get info would be getInfo().<br>
  The guides on how to use these are present at the the  [GSDK Homepage](https://supremainc.github.io/g-sdk/)<br>
  ```python

  import biostarPython as g


  gateway = g.GatewayClient('127.0.0.1',4000,'ca.crt')
  channel = gateway.getChannel()
  connect = g.ConnectSvc(channel)
  face = g.FaceSvc(channel)
  network = g.NetworkSvc(channel)

  deviceInfo = connect.searchDevice(300)

  bs3 = connect.connect(connect.getConnInfo('192.168.0.50', 51211, False))

  face.scan(bs3,4)

  existingConfig = network.getIPConfig(bs3)
  existingConfig.useDHCP = False
  existingConfig.IPAddress = '192.168.0.20'
  network.setIPConfig(bs3, existingConfig)
  ```

  All of the specific APIs can be found at the wiki Above.



  - 0.4.0.2 - Updated proto files to 1.7.1 distribution of GSDK (Template only selection for FaceData and FaceConfig)
  - 0.4.0.1 - Added UpdateSlideImages to DisplaySvc and added Fingerprint to TestSvc.
  - 0.4.0.0 - Updated proto files to 1.7.0 (New Features, BEW3 support), added TestSvc (Waiting on support from device), fixed factoryDefault parameters.
  - 0.3.0.5 - Added UDPSvc for changing IP config via UDP, Updated Proto generation to 1.6.0 version of GSDK.
  - 0.3.0.2 - Fixed no response recieved from some user commands, also added newEventFilter()
            under event service, to create a new Filter.
  - 0.3.0.0 - Support for BS3, VOIP, RTSP and Wiegand User ID
  - 0.2.1.4 - Version Push
  - 0.2.1.2 - Fixed issue with importing none existent package
  - 0.2.1.0 - Addes getJobCode, setJobCode, setJobCodeMulti and setAccessGroupMulti to the UserSvc
  - 0.2.0.1 - Added searchInfoToConnectInfo(self, searchInfo, isAsync) under ConnectSvc, allowing generation of Connection Parameters directly from search results
  - 0.2.0.0 - Upgraded support for gRPC to the newest version supported by python (Regenerated .py files from .proto)
  - 0.1.9.0 - Added zone services, LockZone, APBZone, TimedAPBZone, FireZone, InterlockZone and IntrusionZone are included. Also edited protobuf version to include security fixes (3.20.1)
  - 0.1.8.8 - Fixed minor issue with finger.scan (Did not return data)
  - 0.1.8.6 - Fixed minor issues
  - 0.1.8 - Implemented version check for Protobuf (3.20)
  - 0.1.7 - Implemented proper logging, a GSDKlog.log file is now used instead of the standard print command.
  - 0.1.6 - Added firmwareUpdateMulti to DeviceSvc (Needed for multiple device upgrade internally)
  - 0.1.5 - Added OperatorSvc call so operators above 10 can be added. Supports getList, add, delete, deleteAll, addMulti, deleteMulti and deleteAllMulti
  - 0.1.4 - Added getFinger, getFace and getCard to UserSvc. Added getQRConfig, setQRConfig and writeQR to CardSvc()
  - 0.1.3 - Added AuthSvc, AccessSvc, ScheduleSvc, ActionSvc and TNASvc.
          Under UserSvc, added newUser, newUserCard, newUserFinger and newUserFace for ease of calling when enrolling new user info.
  - 0.1.2 - Updated initial json file string, so import on linux works
  - 0.1.1 - Added Readme
  - 0.1.0 - Initial Commit


pkgId: eb7657e1558d4e149a4f8f987e98fc04e8998d8890212395c4a05036bb67d662
name: python-biosutilities
arch: src
version: 24.11.10
epoch: 0
release: 1
summary: Various BIOS Utilities for Modding/Research
url: https://github.com/platomav/BIOSUtilities
rpm_license: BSD-2-Clause-Patent
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biosutilities-24.11.10-1.src.rpm
checksum_type: sha256
description:
  Various BIOS/UEFI-related utilities which aid in research and/or modding





  The "main" script provides a simple way to check and parse each of the user provided files against all utilities, in succession. It is ideal for quick drag & drop operations but lacks the finer control of the "Package" method. If needed, a few options can be set, by using the command line:

  ``` text
  usage: main.py [-h] [-e] [-o OUTPUT_DIR] [paths ...]

  positional arguments:
    paths

  options:
    -h, --help                              show help and exit
    -e, --auto-exit                         do not pause on exit
    -o OUTPUT_DIR, --output-dir OUTPUT_DIR  extraction directory
  ```

  ``` text
  python ./main.py "/path/to/input/file.bin" --output-dir "/path/to/file extractions"
  ```

  If no arguments/options are provided, the "main" script requests the input and output paths from the user. If no output path is provided, the utility will use the parent directory of the first input file or fallback to the runtime execution directory.

  ``` text
  Enter input file or directory path: "C:\P5405CSA.303"

  Enter output directory path: "C:\P5405CSA.303_output"
  ```



  Each utility is derived from a base "BIOSUtility" template and all utilities form the "biosutilities" python package, which can be installed from PyPi:

  ``` bash
  python -m pip install --upgrade biosutilities[pefile,lznt1]
  ```

  Installing the python package is the recommended way to call one or more utilities programatically, while fully controlling arguments and options.

  ``` python
  from biosutilities.ami_pfat_extract import AmiPfatExtract

  ami_pfat_extractor = AmiPfatExtract(input_object='/path/to/input/file.bin', extract_path='/path/to/output/folder/')

  is_supported = ami_pfat_extractor.check_format()
  is_extracted = ami_pfat_extractor.parse_format()
  ```

  ``` python
  from biosutilities.dell_pfs_extract import DellPfsExtract

  with open('/path/to/input/file.bin', 'rb') as pfs_file:
      pfs_data = pfs_file.read()

  dell_pfs_extractor = DellPfsExtract(input_object=pfs_data, extract_path='/path/to/output/directory/', padding=8)

  is_supported = dell_pfs_extractor.check_format()
  is_extracted = dell_pfs_extractor.parse_format()
  ```



  Each BIOSUtility expects the following required and optional arguments to check and/or parse a given file format:



  ``` python
  input_object: str | bytes | bytearray = b''
  ```



  ``` python
  extract_path: str = runtime_root()
  ```



  ``` python
  padding: int = 0
  ```

  If the required arguments are not provided, placeholder values are set so that it is possible to use the BIOSUtility-inherited instance to access auxiliary public methods and class constants. However, checking and/or parsing of file formats will not yield results.



  Once the BIOSUtility-inherited object is initialized with arguments, its two public methods can be called:



  Check if input object is of specific supported format

  ``` python
  is_supported: bool = check_format()
  ```



  Process input object as a specific supported format

  ``` python
  is_extracted: bool = parse_format()
  ```



  Unless explicitely noted, all utilities should work under Windows, Linux or macOS operating systems which have Python 3.10 - 3.12 support.



  There are two main types of requirements, depending on the utility.



  * [pefile](https://pypi.org/project/pefile/2023.2.7/)
  * [dissect.util](https://pypi.org/project/dissect.util/3.18/)

  Python packages can be installed via Pypi (e.g. pip)

  ``` bash
  python -m pip install --upgrade -r requirements.txt
  ```

  or

  ``` bash
  python -m pip install pefile==2023.2.7 dissect.util==3.18
  ```



  To run the utilities, you must have the following 3rd party tools at PATH or "external":

  * [7-Zip](https://www.7-zip.org/) (i.e. 7z.exe for Windows or 7zz for macOS or 7zz, 7zzs for Linux)
  * [UEFIFind](https://github.com/LongSoft/UEFITool/) (i.e. [UEFIFind.exe for Windows or UEFIFind for Linux/macOS](https://github.com/LongSoft/UEFITool/releases))
  * [UEFIExtract](https://github.com/LongSoft/UEFITool/) (i.e. [UEFIExtract.exe for Windows or UEFIExtract for Linux/macOS](https://github.com/LongSoft/UEFITool/releases))
  * [TianoCompress](https://github.com/tianocore/edk2/tree/master/BaseTools/Source/C/TianoCompress/) (i.e. [TianoCompress.exe for Windows](https://github.com/tianocore/edk2-BaseTools-win32/) or TianoCompress for Linux/macOS)
  * [ToshibaComExtractor](https://github.com/LongSoft/ToshibaComExtractor) (i.e. [comextract.exe for Windows or comextract for Linux/macOS](https://github.com/LongSoft/ToshibaComExtractor/releases))

  Note: On Linux, you need to compile "comextract" from sources as no pre-built binary exists.
  Note: On Linux and macOS, you need to compile "TianoCompress" from sources as no pre-built binary exists.

  Optionally, to decompile the Intel BIOS Guard Scripts (when applicable), you must have the following 3rd party python script at PATH or "external":

  * [BIOS Guard Script Tool](https://github.com/platomav/BGScriptTool) (i.e. big_script_tool.py)

  External executables and/or scripts (e.g. TianoCompress.exe, big_script_tool.py, 7z.exe) need to be found via the "PATH" environment variable, which is configured differently depending on the operating system.

  Alternatively, if neither modifying PATH environment variable nor copying the executables in standard OS PATH directories is an option, you can create a folder "external" at the root of the "biosutilities" project.



  [Linux Path](https://www.digitalocean.com/community/tutorials/how-to-view-and-update-the-linux-path-environment-variable)

  or

  ``` bash
  sudo install "/path/to/downloaded/executable" /usr/local/bin
  ```



  [Windows Path](https://www.computerhope.com/issues/ch000549.htm)

  Note: In the "Environment Variables" window, you can modify the "Path" variable under "User variables" instead of "System variables", contrary to what many guides suggest.



  [Mac Path](https://mac.install.guide/terminal/path)



  * [AMI BIOS Guard Extractor](#ami-bios-guard-extractor)
  * [AMI UCP Update Extractor](#ami-ucp-update-extractor)
  * [Apple EFI IM4P Splitter](#apple-efi-im4p-splitter)
  * [Apple EFI Image Identifier](#apple-efi-image-identifier)
  * [Apple EFI Package Extractor](#apple-efi-package-extractor)
  * [Apple EFI PBZX Extractor](#apple-efi-pbzx-extractor)
  * [Award BIOS Module Extractor](#award-bios-module-extractor)
  * [Dell PFS Update Extractor](#dell-pfs-update-extractor)
  * [Fujitsu SFX BIOS Extractor](#fujitsu-sfx-bios-extractor)
  * [Fujitsu UPC BIOS Extractor](#fujitsu-upc-bios-extractor)
  * [Insyde iFlash/iFdPacker Extractor](#insyde-iflashifdpacker-extractor)
  * [Panasonic BIOS Package Extractor](#panasonic-bios-package-extractor)
  * [Phoenix TDK Packer Extractor](#phoenix-tdk-packer-extractor)
  * [Portwell EFI Update Extractor](#portwell-efi-update-extractor)
  * [Toshiba BIOS COM Extractor](#toshiba-bios-com-extractor)
  * [VAIO Packaging Manager Extractor](#vaio-packaging-manager-extractor)





  Parses AMI BIOS Guard (a.k.a. PFAT, Platform Firmware Armoring Technology) images, extracts their SPI/BIOS/UEFI firmware components and optionally decompiles the Intel BIOS Guard Scripts. It supports all AMI PFAT revisions and formats, including those with Index Information tables or nested AMI PFAT structures. The output comprises only final firmware components which are directly usable by end users.

  Note that the AMI PFAT structure may not have an explicit component order. AMI's BIOS Guard Firmware Update Tool (AFUBGT) updates components based on the user/OEM provided Parameters and Options or Index Information table, when applicable. Thus, merging all the components together does not usually yield a proper SPI/BIOS/UEFI image. The utility does generate such a merged file with the name "00 -- \<filename\>\_ALL.bin" but it is up to the end user to determine its usefulness. Additionally, any custom OEM data, after the AMI PFAT structure, is stored in the last file with the name "\<n+1\> -- \_OOB.bin" and it is once again up to the end user to determine its usefulness. In cases where the trailing custom OEM data includes a nested AMI PFAT structure, the utility will process and extract it automatically as well.



  No additional optional arguments are provided for this utility.



  * BIOS Guard Script Tool (optional)





  Parses AMI UCP (Utility Configuration Program) Update executables, extracts their firmware components (e.g. SPI/BIOS/UEFI, EC, ME etc) and shows all relevant info. It supports all AMI UCP revisions and formats, including those with nested AMI PFAT, AMI UCP or Insyde iFlash/iFdPacker structures. The output comprises only final firmware components and utilities which are directly usable by end users.



  Additional optional arguments are provided for this utility:

  * checksum -> bool : verify AMI UCP Checksums (slow)



  * 7-Zip (required)
  * TianoCompress (required)
  * BIOS Guard Script Tool (optional)





  Parses Apple IM4P multi-EFI files and splits all detected EFI firmware into separate Intel SPI/BIOS images. The output comprises only final firmware components and utilities which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  No additional requirements are needed for this utility.





  Parses Apple EFI images and identifies them based on Intel's official "IBIOSI" tag, which contains info such as Model, Version, Build, Date and Time. Additionally, the utility can provide both "IBIOSI" and "Apple ROM Version" structure info, when available, as well as a suggested EFI image filename, while also making sure to differentiate any EFI images with the same "IBIOSI" tag (e.g. Production, Pre-Production) by appending a checksum of their data.



  Additional optional arguments are provided for this utility:

  * silent -> bool : suppress structure display

  The utility exposes certain public class attributes, once parse_format() method has been successfully executed:

  * efi_file_name -> str : Suggested image filename, based on Intel "IBIOSI" information
  * intel_bios_info -> dict[str, str] : Information contained at Intel "IBIOSI" structure
  * apple_rom_version -> dict[str, str] : Information contained at "Apple ROM Version" structure



  * UEFIFind (required)
  * UEFIExtract (required)





  Parses Apple EFI PKG firmware packages (e.g. FirmwareUpdate.pkg, BridgeOSUpdateCustomer.pkg, InstallAssistant.pkg, iMacEFIUpdate.pkg, iMacFirmwareUpdate.tar), extracts their EFI images, splits those in IM4P format and identifies/renames the final Intel SPI/BIOS images accordingly. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * 7-Zip (required)
  * UEFIFind (required)
  * UEFIExtract (required)





  Parses Apple EFI PBZX images, re-assembles their CPIO payload and extracts its firmware components (e.g. IM4P, EFI, Utilities, Scripts etc). It supports CPIO re-assembly from both Raw and XZ compressed PBZX Chunks. The output comprises only final firmware components and utilities which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * 7-Zip (required)





  Parses Award BIOS images and extracts their modules (e.g. RAID, MEMINIT, \_EN_CODE, awardext etc). It supports all Award BIOS image revisions and formats, including those which contain LZH compressed files. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * 7-Zip (required)





  Parses Dell PFS Update images and extracts their Firmware (e.g. SPI, BIOS/UEFI, EC, ME etc) and Utilities (e.g. Flasher etc) component sections. It supports all Dell PFS revisions and formats, including those which are originally LZMA compressed in ThinOS packages (PKG), ZLIB compressed or Intel BIOS Guard (PFAT) protected. The output comprises only final firmware components which are directly usable by end users.



  Additional optional arguments are provided for this utility:

  * advanced -> bool : extract signatures and metadata
  * structure -> bool : show PFS structure information



  * BIOS Guard Script Tool (optional)





  Parses Fujitsu SFX BIOS images and extracts their obfuscated Microsoft CAB archived firmware (e.g. SPI, BIOS/UEFI, EC, ME etc) and utilities (e.g. WinPhlash, PHLASH.INI etc) components. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * 7-Zip (required)





  Parses Fujitsu UPC BIOS images and extracts their EFI compressed SPI/BIOS/UEFI firmware component. The output comprises only a final firmware component which is directly usable by end users.



  No additional optional arguments are provided for this utility.



  * TianoCompress (required)





  Parses Insyde iFlash/iFdPacker Update images and extracts their firmware (e.g. SPI, BIOS/UEFI, EC, ME etc) and utilities (e.g. InsydeFlash, H2OFFT, FlsHook, iscflash, platform.ini etc) components. It supports all Insyde iFlash/iFdPacker revisions and formats, including those which are 7-Zip SFX 7z compressed in raw, obfuscated or password-protected form. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  No additional requirements are needed for this utility.





  Parses Panasonic BIOS Package executables and extracts their firmware (e.g. SPI, BIOS/UEFI, EC etc) and utilities (e.g. winprom, configuration etc) components. It supports all Panasonic BIOS Package revisions and formats, including those which contain LZNT1 compressed files and/or AMI PFAT payloads. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * 7-Zip (required)
  * pefile (required)
  * dissect.util (required)





  Parses Phoenix Tools Development Kit (TDK) Packer executables and extracts their firmware (e.g. SPI, BIOS/UEFI, EC etc) and utilities (e.g. WinFlash etc) components. It supports all Phoenix TDK Packer revisions and formats, including those which contain LZMA compressed files. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * pefile (required)





  Parses Portwell UEFI Unpacker EFI executables (usually named "Update.efi") and extracts their firmware (e.g. SPI, BIOS/UEFI, EC etc) and utilities (e.g. Flasher etc) components. It supports all known Portwell UEFI Unpacker revisions (v1.1, v1.2, v2.0) and formats (used, empty, null), including those which contain EFI compressed files. The output comprises only final firmware components and utilities which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * pefile (required)
  * TianoCompress (required)





  Parses Toshiba BIOS COM images and extracts their raw or compressed SPI/BIOS/UEFI firmware component. This utility is effectively a python wrapper around [ToshibaComExtractor by LongSoft](https://github.com/LongSoft/ToshibaComExtractor). The output comprises only a final firmware component which is directly usable by end users.



  No additional optional arguments are provided for this utility.



  * ToshibaComExtractor (required)





  Parses VAIO Packaging Manager executables and extracts their firmware (e.g. SPI, BIOS/UEFI, EC, ME etc), utilities (e.g. WBFLASH etc) and driver (audio, video etc) components. If direct extraction fails, it attempts to unlock the executable in order to run at all non-VAIO systems and allow the user to choose the extraction location. It supports all VAIO Packaging Manager revisions and formats, including those which contain obfuscated Microsoft CAB archives or obfuscated unlock values. The output comprises only final firmware components which are directly usable by end users.



  No additional optional arguments are provided for this utility.



  * 7-Zip (required)


pkgId: c3529a6a9d4301a7789d455d2aabc04ce326d63c19be2ef617a47f91a8264a83
name: python-biotrade
arch: src
version: 0.3.16
epoch: 0
release: 1
summary: Agriculture and forestry statistics.
url: https://gitlab.com/bioeconomy/forobs/biotrade/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biotrade-0.3.16-1.src.rpm
checksum_type: sha256
description:
  The `biotrade` package analyses international trade of bio-based products. It focuses on
  the agriculture and forestry sectors, from primary production to secondary products
  transformation. It loads bilateral trade data from UN Comtrade, production and trade
  data from FAOSTAT and socio-economic indicators from the World Bank.




  The documentation is available at:
  https://bioeconomy.gitlab.io/forobs/biotrade/






  Install the biotrade package from the python package index with pip:

      python -m pip install biotrade

  Upgrade the package to the latest version with:

      python -m pip install --upgrade biotrade

  To install the latest development version, use the `--upgrade` parameter and install
  from the main branch of the gitlab repository:

      python -m pip install --upgrade --force-reinstall https://gitlab.com/bioeconomy/forobs/biotrade/-/archive/main/biotrade-main.tar.gz




  If you plan to contribute to the development of the biotrade package, clone the biotrade
  repository at https://gitlab.com/bioeconomy/forobs/biotrade/. You need to tell python
  where the package is located by adding it to your PYTHONPATH. You can do this by
  changing the environment variables or by adding the following line to your shell
  configuration file such as `.bash_aliases`:

      export PYTHONPATH="$HOME/repos/biotrade/":$PYTHONPATH

  Specify where you want to store the data by adding the following environment variable:

      export BIOTRADE_DATA="$HOME/repos/biotrade_data/"

  Dependencies are listed in the `install_requires` argument of [setup.py](setup.py).




  The biotrade package can download data from FAOSTAT and UN Comtrade and store it inside
  a database. By default it will use an SQLite database stored locally in the folder
  defined by the environment variable `BIOTRADE_DATA`. Alternatively, a PostGRESQL
  database can be used if a connection string is defined in the environment variable
  `BIOTRADE_DATABASE_URL`, for example by adding the following to your .bash_aliases or
  .bash_rc:

      export BIOTRADE_DATABASE_URL="postgresql://user@localhost/biotrade"

  Note that database queries are abstracted with [SQL
  Alchemy](https://www.sqlalchemy.org/) which is what makes it possible to use different
  database engines. SQLite is convenient for data analysis on laptops. PostGreSQL can be
  used on servers.




  Faostat provides agriculture and forestry data on their website https://www.fao.org/faostat/en/#data/

  The biotrade package has a `faostat.pump` object that loads a selection of datasets. The
  list of downloaded datasets is visible in `faostat.pump.datasets`. Column names and
  product descriptions are reformatted to snake case in a way that is convenient for
  analysis. The data is then stored into an SQLite database (or PostgreSQL). The following
  commands download and transfer the given datasets to the database:

      >>> from biotrade.faostat import faostat
      >>> faostat.pump.update(["crop_production", "forestry_production"])
      >>> # Loading trade data can take a long time on slow connections
      >>> faostat.pump.update(["crop_trade", "forestry_trade"])
      >>> faostat.pump.update(["food_balance"])
      >>> faostat.pump.update(["land_use", "land_cover", "forest_land"])

  List available datasets and metadata links:

      >>> faostat.pump.datasets
      >>> faostat.pump.metadata_link

  Once the data has been loaded into the database, you can query it. For example select
  crop production data for 2 countries

      >>> from biotrade.faostat import faostat
      >>> db = faostat.db_sqlite
      >>> cp2 = db.select(table="crop_production",
      >>>                 reporter=["Portugal", "Estonia"])

  Select forestry trade flows data reported by all countries, with
  Austria as a partner country:

      >>> ft_aut = db.select(table="forestry_trade",
      >>>                    partner=["Austria"])

  Select crop trade flows reported by the Netherlands where Brazil was a
  partner

      >>> ct_nel_bra = db.select(table="crop_trade",
      >>>                        reporter="Netherlands",
      >>>                        partner="Brazil")

  Select the mirror flows reported by Brazil, where the Netherlands was a partner

      >>> ct_bra_bel = db.select(table="crop_trade",
      >>>                        reporter="Brazil",
      >>>                        partner="Netherlands")

  Select land use and land cover data

      >>> lu = faostat.db.select("land_use")
      >>> lc = faostat.db.select("land_cover")




  See the documentation of the various methods. As an example  here is how to download
  trade data from the Comtrade API and return a data frame, for debugging purposes:

      >>> from biotrade.comtrade import comtrade
      >>> # Other sawnwood
      >>> swd99 = comtrade.pump.download(cc = "440799")
      >>> # Soy
      >>> soy = comtrade.pump.download(cc = "120190")

  Display information on column names used for renaming
  and dropping less important columns:

      >>> comtrade.column_names

  Get the list of products from the Comtrade API

      >>> hs = comtrade.pump.get_parameter_list("classificationHS.json")

  Get the list of reporter and partner countries

      >>> comtrade.pump.get_parameter_list("reporterAreas.json")
      >>> comtrade.pump.get_parameter_list("partnerAreas.json")








  FAOSTAT release dates are available at :
  https://fenixservices.fao.org/faostat/static/releasecalendar/Default.aspx




  Column names and product descriptions are reformatted to snake case in a way that is
  convenient for analysis. See example below.

  - Variables are defined and compared between the data sources in a notebook called
    [definitions_and_harmonization](notebooks/definitions_and_harmonization.md)

  - Variable names are harmonized between the different sources using a mapping table
    defined in
    [biotrade/config_data/column_names.csv](https://gitlab.com/bioeconomy/biotrade/-/blob/main/biotrade/config_data/column_names.csv)
    See for example how the `product_code` column is called  `PRODUCT_NC` in Eurostat Comext,
    `commodity_code` or `cmdcode` in UN Comtrade and `item_code` in FAOSTAT.

  - `snake_case` is the preferred way of naming files and variables in the code. This
    follows the R [tidyverse style guide for object
    names](https://style.tidyverse.org/syntax.html) and the python [PEP
    8](https://www.python.org/dev/peps/pep-0008/#function-and-variable-names) style guide
    for function and variable names.

  To illustrate the advantage of using snake case for data exploration, compare the use of
  column names with space which have to be quoted. Python

      >>> df["Product Code"]
      >>> df.product_code

  R

      R> df["Product Code"]
      R> df$`Product Code`
      R> df$product_code




  The `biotrade` package stores a small amount of configuration data such as country and
  product mapping tables and conversion coefficients in the `biotrade/config_data` folder.





  This software is licenced under the MIT licence.
  See the [LICENCE.md](LICENCE.md) file.




  - The R packages FAOSTAT and WDI




  This package uses pytest for unit testing. Run the test suite with

      pytest

  Run pytest with code coverage

      cd python_project_dir
      coverage run --source=. -m pytest

  Followed by

      coverage html

  To generate a report.
  These tests are run as part of the Continuous Integration.




  The authors would like to acknowledge ideas and feedback received from the following
  persons: Giovanni Bausano, Noemi Cazzaniga, Mirco Migliavacca, Roberto Pilli, Lucas
  Sinclair.


pkgId: 6495484acd9caf0c8c23190a50b593f47a3c9513d4c10abd9ba2306c4e2c0536
name: python-bioutils
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: miscellaneous simple bioinformatics utilities and lookup tables
url: https://github.com/biocommons/bioutils
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioutils-0.6.0-1.src.rpm
checksum_type: sha256
description:
  bioutils -- bioinformatics utilities and lookup tables
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  |pypi_badge| |build_status| |cov_badge| |cc_badge| |issues_badge| |contributors| |license| |changelog|


  bioutils provides some common utilities and lookup tables for bioinformatics.

  * bioutils.accessions -- parse accessions, infer namespaces
  * bioutils.assemblies -- Human assembly information (from NCBI/GRCh)
  * bioutils.cytobands -- map cytobands to coordinates (from UCSC cytoband tables)
  * bioutils.digests -- implementations of various digests
  * bioutils.normalize -- allele normalization (left shuffle, right shuffle, expanded, vcf)


  To use an E-Utilities API key run add it to an environment variable
  called `ncbi_api_key` and it will be used in the E-Utilities request.


  .. |build_status| image:: https://travis-ci.org/biocommons/bioutils.svg?branch=master
    :target: https://travis-ci.org/biocommons/bioutils

  .. |changelog| image:: https://img.shields.io/badge/docs-changelog-green.svg
     :target: https://bioutils.readthedocs.io

  .. |contributors| image:: https://img.shields.io/github/contributors/biocommons/bioutils.svg
    :target: https://github.com/biocommons/bioutils

  .. |docs| image:: https://img.shields.io/badge/docs-readthedocs-green.svg
     :target: http://bioutils.readthedocs.io/

  .. |issues_badge| image:: https://img.shields.io/github/issues/biocommons/bioutils.png
    :target: https://github.com/biocommons/bioutils/issues

  .. |license| image:: https://img.shields.io/github/license/biocommons/bioutils.svg
    :target: https://github.com/biocommons/bioutils/blob/master/LICENSE

  .. |pypi_badge| image:: https://img.shields.io/pypi/v/bioutils.svg
    :target: https://pypi.org/project/bioutils/


  .. |cc_badge| image:: https://api.codeclimate.com/v1/badges/3a99e06ad0a842174b0a/maintainability
     :target: https://codeclimate.com/github/biocommons/bioutils/maintainability
     :alt: Maintainability

  .. |cov_badge| image:: https://coveralls.io/repos/github/biocommons/bioutils/badge.svg?branch=master
     :target: https://coveralls.io/github/biocommons/bioutils?branch=master

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2019 bioutils Contributors  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


