# packages

pkgId: 78f842f8a54af72312c69ad47b2d09a9153463e84c451d32d2e36c48cd02528a
name: python-bloonspy
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: A Python wrapper for the Ninja Kiwi Open Data API
url: https://github.com/SartoRiccardo/bloonspy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bloonspy-0.9.2-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/bloonspy/badge/?version=latest)](https://bloonspy.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/bloonspy)](https://pypi.org/project/bloonspy/)

  BloonsPy is a Python wrapper for the [Ninja Kiwi Open Data API](https://data.ninjakiwi.com/),
  that makes you write more readable code and handles rate limiting automatically.
  It also renames cryptic variable names so you can know what you're doing while coding.



  **Python 3.10 or higher is required**

  ```bash
  python3 -m pip install bloonspy
  ```



  ```python
  from bloonspy import Client

  boss_event = Client.bosses()[0].standard()
  boss_standard_top_3 = boss_event.leaderboard()[:3]
  for player in boss_standard_top_3:
      print(f"{player.name} - {player.score}")
  ```


  + [Documentation](https://bloonspy.readthedocs.io/en/latest/)
  + [Github](https://github.com/SartoRiccardo/bloonspy)


pkgId: 8a48411dfb52f0708848d7d038f968e75ca2deec8f1cd4c362cf9835351b69ee
name: python-blossy
arch: src
version: 7.3
epoch: 0
release: 1
summary: A lil' bud that helps you with stuff (it's a utility CLI).
url: https://pypi.org/project/blossy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blossy-7.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">  🌸  Blossy CLI  🌸  </h1>

  A multiuse utility CLI tool developed using:

  - Python
  - Typer (CLI building)
  - Sly Lex Yacc (parsing)



  - [x] Calculate the value of an expression
  - [x] Calculate the value of an expression using time
  - [x] Count the quantity of characters in a text file
  - [x] Solve percentage equations
  - [x] Generate random numbers
  - [x] Stardardize the names of the files in a directory



  To install the CLI, you'll only need to have Python installed on your machine. Then, run the following command:

  ```bash
  $ python3 -m pip install blossy
  ```





  To calculate the value of an expression, use the `calc` command. The following operators are supported:

  - (expr)
  - \+ expr
  - \- expr
  - expr ^ expr
  - expr * expr
  - expr / expr
  - expr + expr
  - expr - expr

  ```bash
  $ blossy calc "2*3+4^6"
  4102
  ```

  You can use the `--visualize` flag to see the steps of the calculation, illustrated using postfix notation and a stack.

  ```bash
  $ blossy calc "2*3+4^6" --visualize

  $                                                          2 3 * 4 6 ^ +₂ $

  > Stack 2

  $ 2                                                          3 * 4 6 ^ +₂ $

  > Stack 3

  $ 2 3                                                          * 4 6 ^ +₂ $

  > 2 * 3 = 6

  $ 6                                                              4 6 ^ +₂ $

  > Stack 4

  $ 6 4                                                              6 ^ +₂ $

  > Stack 6

  $ 6 4 6                                                              ^ +₂ $

  > 4^6 = 4096

  $ 6 4096                                                               +₂ $

  > 6 + 4096 = 4102

  $ 4102                                                                    $

  > The result is 4102
  ```



  To calculate the value of an expression using time, use the `calct` command. The following operators are supported:

  - (expr)
  - \+ expr
  - \- expr
  - expr ^ expr
  - expr * expr
  - expr / expr
  - expr + expr
  - expr - expr

  ```bash
  $ blossy calct "1:02:00 + 12:01*2"
  1:26:02
  ```

  You can use the `--visualize` flag to see the steps of the calculation, illustrated using postfix notation and a stack.

  ```bash
  $ blossy calct "1:02:00 + 12:01*2" --visualize

  $                                                    1:02:00 12:01 2 * +₂ $

  > Stack 1:02:00

  $ 1:02:00                                                    12:01 2 * +₂ $

  > Stack 12:01

  $ 1:02:00 12:01                                                    2 * +₂ $

  > Stack 2

  $ 1:02:00 12:01 2                                                    * +₂ $

  > 12:01 * 2 = 0:24:02

  $ 1:02:00 0:24:02                                                      +₂ $

  > 1:02:00 + 0:24:02 = 1:26:02

  $ 1:26:02                                                                 $

  > The result is 1:26:02
  ```



  To count the quantity of characters in a text file, use the `calc` command.

  ```bash
  $ blossy count file.txt
  Character count: 58
  ```

  ```
  Blossy is my favorite puppy.

  Did somebody say meatloaf?


  ```

  You can use the `--ignore-unnec` flag to ignore unnecessary whitespaces. That way, a sequence of whitespaces will be counted as only one character, and trailing whitespaces will be completely ignored.

  ```bash
  $ blossy count file.txt --ignore-unnec
  Character count: 55
  ```

  ```
  Blossy is my favorite puppy. Did somebody say meatloaf?
  ```

  You can also use the `--ignore-ws` flag to ignore all whitespaces.

  ```bash
  $ blossy count file.txt --ignore-ws
  Character count: 47
  ```

  ```
  Blossyismyfavoritepuppy.Didsomebodysaymeatloaf?
  ```



  To solve percentage equations, use the `perc` command. This command uses the formula `ratio = part/whole`.

  ```bash
  $ blossy perc --whole 100 --ratio 0.25
  Part: 25.0
  $ blossy perc --whole 100 --part 25
  Ratio: 0.25
  ```



  To generate a random number between two given values (inclusive), use the `rand` command.

  ```bash
  $ blossy rand 1 10
  2
  ```

  You can specify the quantity of random numbers that'll be generated (the default is 1):

  ```bash
  $ blossy rand 1 10 --quantity 5
  2 7 1 5 1
  ```



  To rename the files in a directory, using the format `{prefix}-{id}`, use the `stddz` command. Here's an example of how to use the command:

  ```bash
  $ blossy stddz my-johnson nice-folder/
  ```

  ```
  nice-folder/
  ├── my-johnson-000.png
  ├── my-johnson-001.png
  ├── my-johnson-002.png
  └── my-johnson-003.png
  ```

  You can use the flag `--start` to specify the starting number for the IDs:

  ```bash
  $ blossy stddz my-johnson nice-folder/ --start 10
  ```

  ```
  nice-folder/
  ├── my-johnson-010.png
  ├── my-johnson-011.png
  ├── my-johnson-012.png
  └── my-johnson-013.png
  ```

  You can also use the flag `--digits` to specify the quantity of digits that'll be used to represent the IDs (the default is 3):

  ```bash
  $ blossy stddz my-johnson nice-folder/ --digits 2
  ```

  ```
  nice-folder/
  ├── my-johnson-00.png
  ├── my-johnson-01.png
  ├── my-johnson-02.png
  └── my-johnson-03.png
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Ryan Sakurai  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: c5c6f1f278e86817f5e6c25c443a6bcc5179cf1a95c9ac7de55ce2b763deed11
name: python-blossy
arch: src
version: 8.1
epoch: 0
release: 1
summary: A lil' bud that helps you with stuff (it's a utility CLI).
url: https://pypi.org/project/blossy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blossy-8.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">  🌸  Blossy CLI  🌸  </h1>

  A multiuse utility CLI tool developed using:

  - Python;
  - Typer: building the CLI;
  - Sly Lex Yacc: parsing text.



  - [x] Calculate the value of an expression
  - [x] Calculate the value of an expression using time
  - [x] Count the quantity of characters in a text file
  - [x] Solve percentage equations
  - [x] Generate random numbers
  - [x] Stardardize the names of the files in a directory



  To install the CLI, you'll only need to have Python installed on your machine. Then, run the following command:

  ```bash
  $ python3 -m pip install blossy
  ```





  To calculate the value of an expression, use the `calc` command. The following operators are supported:

  - (expr)
  - \+ expr
  - \- expr
  - expr ^ expr
  - expr * expr
  - expr / expr
  - expr + expr
  - expr - expr

  ```bash
  $ blossy calc "2*3+4^6"
  4102
  ```

  You can use the `--visualize` flag to see the steps of the calculation, illustrated using postfix notation and a stack.

  ```bash
  $ blossy calc "2*3+4^6" --visualize

  $                                                          2 3 * 4 6 ^ +₂ $

  > Stack 2

  $ 2                                                          3 * 4 6 ^ +₂ $

  > Stack 3

  $ 2 3                                                          * 4 6 ^ +₂ $

  > 2 * 3 = 6

  $ 6                                                              4 6 ^ +₂ $

  > Stack 4

  $ 6 4                                                              6 ^ +₂ $

  > Stack 6

  $ 6 4 6                                                              ^ +₂ $

  > 4^6 = 4096

  $ 6 4096                                                               +₂ $

  > 6 + 4096 = 4102

  $ 4102                                                                    $

  > The result is 4102
  ```



  To calculate the value of an expression using time, use the `calct` command. The following operators are supported:

  - (expr)
  - \+ expr
  - \- expr
  - expr ^ expr
  - expr * expr
  - expr / expr
  - expr + expr
  - expr - expr

  ```bash
  $ blossy calct "1:02:00 + 12:01*2"
  1:26:02
  ```

  You can use the `--visualize` flag to see the steps of the calculation, illustrated using postfix notation and a stack.

  ```bash
  $ blossy calct "1:02:00 + 12:01*2" --visualize

  $                                                    1:02:00 12:01 2 * +₂ $

  > Stack 1:02:00

  $ 1:02:00                                                    12:01 2 * +₂ $

  > Stack 12:01

  $ 1:02:00 12:01                                                    2 * +₂ $

  > Stack 2

  $ 1:02:00 12:01 2                                                    * +₂ $

  > 12:01 * 2 = 0:24:02

  $ 1:02:00 0:24:02                                                      +₂ $

  > 1:02:00 + 0:24:02 = 1:26:02

  $ 1:26:02                                                                 $

  > The result is 1:26:02
  ```



  To count the quantity of characters in a text file, use the `calc` command.

  ```bash
  $ blossy count file.txt
  Character count: 58
  ```

  ```
  Blossy is my favorite puppy.

  Did somebody say meatloaf?


  ```

  You can use the `--ignore-unnec` flag to ignore unnecessary whitespaces. That way, a sequence of whitespaces will be counted as only one character, and trailing whitespaces will be completely ignored.

  ```bash
  $ blossy count file.txt --ignore-unnec
  Character count: 55
  ```

  ```
  Blossy is my favorite puppy. Did somebody say meatloaf?
  ```

  You can also use the `--ignore-ws` flag to ignore all whitespaces.

  ```bash
  $ blossy count file.txt --ignore-ws
  Character count: 47
  ```

  ```
  Blossyismyfavoritepuppy.Didsomebodysaymeatloaf?
  ```



  To solve percentage equations, use the `perc` command. This command uses the formula `ratio = part/whole`.

  ```bash
  $ blossy perc --whole 100 --ratio 0.25
  Part: 25.0
  $ blossy perc --whole 100 --part 25
  Ratio: 0.25
  ```



  To generate a random number between two given values (inclusive), use the `rand` command.

  ```bash
  $ blossy rand 1 10
  2
  ```

  You can specify the quantity of random numbers that'll be generated (the default is 1):

  ```bash
  $ blossy rand 1 10 --quantity 5
  2 7 1 5 1
  ```



  To rename the files in a directory, using the format `{prefix}-{id}`, use the `stddz` command. Here's an example of how to use the command:

  ```bash
  $ blossy stddz my-johnson nice-folder/
  ```

  ```
  nice-folder/
  ├── my-johnson-000.png
  ├── my-johnson-001.png
  ├── my-johnson-002.png
  └── my-johnson-003.png
  ```

  You can use the flag `--start` to specify the starting number for the IDs:

  ```bash
  $ blossy stddz my-johnson nice-folder/ --start 10
  ```

  ```
  nice-folder/
  ├── my-johnson-010.png
  ├── my-johnson-011.png
  ├── my-johnson-012.png
  └── my-johnson-013.png
  ```

  You can also use the flag `--digits` to specify the quantity of digits that'll be used to represent the IDs (the default is 3):

  ```bash
  $ blossy stddz my-johnson nice-folder/ --digits 2
  ```

  ```
  nice-folder/
  ├── my-johnson-00.png
  ├── my-johnson-01.png
  ├── my-johnson-02.png
  └── my-johnson-03.png
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Ryan Sakurai  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: cc92d6755f061c7c18e52310798cdfd4ed9f0b215d787d0fa624dd15cfe00912
name: python-blosum
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: A simple BLOSUM toolbox without dependencies.
url: https://github.com/not-a-feature/blosum
rpm_license: gpl-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blosum-2.0.3-1.src.rpm
checksum_type: sha256
description:
  ![blosum](https://github.com/not-a-feature/blosum/raw/main/blosum.png)

  A small module for easy access to BLOSUM matrices without dependencies.

  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7084916.svg)](https://doi.org/10.5281/zenodo.7084916)
  [![Citation Badge](https://api.juleskreuer.eu/citation-badge.php?doi=10.5281/zenodo.7748749)](https://juleskreuer.eu/projekte/citation-badge/)
  ![Test Badge](https://github.com/not-a-feature/blosum/actions/workflows/tests.yml/badge.svg)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)<br>
  ![Download Badge](https://img.shields.io/pypi/dm/blosum.svg)
  ![Python Version Badge](https://img.shields.io/pypi/pyversions/blosum)
  [![install with bioconda](https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg?style=flat)](http://bioconda.github.io/recipes/blosum/README.html)

  The BLOcks SUbstitution Matrices (BLOSUM) are used to score alignments between protein sequences and are therefore mainly used in bioinformatics.

  Reading such matrices is not particularly difficult, yet most off the shelf packages are overloaded with strange dependencies.
  And why do we need to implement the same reader again if there is a simple module for that.

  `blosum` offers a robust and easy-to-expand implementation without relying on third-party libraries.



  Using pip  / pip3:
  ```bash
  pip install blosum
  ```
  Or by source:
  ```bash
  git clone git@github.com:not-a-feature/blosum.git
  cd blosum
  pip install .
  ```

  Or by conda:
  ```bash
  conda install blosum
  ```



  This package provides the most commonly used BLOSUM matrices.
  You can choose from BLOSUM 45, 50, 62, 80 and 90.

  To load a matrix:
  ```python
  import blosum as bl
  matrix = bl.BLOSUM(62)
  val = matrix["A"]["Y"]
  ```


  In addition, own matrices can be loaded. For this, the path is given as an argument.

  ```python
  import blosum as bl
  matrix = bl.BLOSUM("path/to/blosum.file")
  val = matrix["A"]["Y"]
  ```

  The matrices are required to have following format:

  ```


     A  R  N  D
  A  5 -2 -1 -2
  R -2  7  0 -1
  N -1  0  6  2
  D -2 -1  2  7
  ```


  Once loaded the `matrix` behaves like a `defaultdict`.
  To get a value use:

  ```python
  val = matrix["A"]["Y"]
  ```
  To get a defaultdict of the row with a given key use:

  ```python
  val_dict = matrix["A"]
  ```


  If the key cannot be found, the default value `float("-inf")` is returned.
  It is possible to set a custom default score:
  ```python
  matrix = bl.BLOSUM(62, default=0)
  ```


  Copyright (C) 2023 by Jules Kreuer - @not_a_feature

  This piece of software is published unter the GNU General Public License v3.0
  TLDR:

  | Permissions      | Conditions                   | Limitations |
  | ---------------- | ---------------------------- | ----------- |
  | ✓ Commercial use | Disclose source              | ✕ Liability |
  | ✓ Distribution   | License and copyright notice | ✕ Warranty  |
  | ✓ Modification   | Same license                 |             |
  | ✓ Patent use     | State changes                |             |
  | ✓ Private use    |                              |             |

  Go to [LICENSE.md](https://github.com/not-a-feature/blosum/blob/main/LICENSE) to see the full version.


pkgId: bbc2d65fbfc57b2caeb5643045419c833c2e03f6926267e463ca8699386c5abc
name: python-blp
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Pythonic interface for Bloomberg Open API
url: https://github.com/matthewgilbert/blp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blp-0.0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/blp.svg)](https://badge.fury.io/py/blp)
  [![Conda](https://img.shields.io/conda/v/conda-forge/blp)](https://anaconda.org/conda-forge/blp)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5187880.svg)](https://doi.org/10.5281/zenodo.5187880)



  `blp` provides a simple pythonic interface to the `blpapi` package. `blp` is the next iteration of the
  [pdblp](https://github.com/matthewgilbert/pdblp) package. `blp` was designed with the following in mind

  1. Explicit separation of session management, event parsing and event aggregation
  2. Extensibility



  You can install from PyPI using

  ```
  pip install blp
  ```

  or from conda-forge using

  ```
  conda install -c conda-forge blp
  ```



  Reading the docs is the best way to get started, take a look at
  [Quickstart](https://matthewgilbert.github.io/blp/quickstart.html) or if you are having issues
  [Troubleshooting](https://matthewgilbert.github.io/blp/quickstart.html#Troubleshooting)



  Please refer to [Contributing](https://matthewgilbert.github.io/blp/contributing.html) for guidelines on contributing.



  For documentation on the Bloomberg API check out the Developer's Guide. For documentation on relevant Bloomberg fields
  for accessing data, check out the Reference Guide: Services and Schemas. To access these, from a  Bloomberg Terminal
  go `WAPI <GO>` -> `API Developer's Guide`.


pkgId: 750e68cc7d6d058e04bac0c13ef51bf77152ac348634f26b6235d97954367faa
name: python-blue-objects
arch: src
version: 5.203.1
epoch: 0
release: 1
summary: 🌀 data objects for Bash.
url: https://github.com/kamangir/blue-objects
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blue-objects-5.203.1-1.src.rpm
checksum_type: sha256
description:
  [![pylint](https://github.com/kamangir/blue-objects/actions/workflows/pylint.yml/badge.svg)](https://github.com/kamangir/blue-objects/actions/workflows/pylint.yml) [![pytest](https://github.com/kamangir/blue-objects/actions/workflows/pytest.yml/badge.svg)](https://github.com/kamangir/blue-objects/actions/workflows/pytest.yml) [![bashtest](https://github.com/kamangir/blue-objects/actions/workflows/bashtest.yml/badge.svg)](https://github.com/kamangir/blue-objects/actions/workflows/bashtest.yml) [![PyPI version](https://img.shields.io/pypi/v/blue-objects.svg)](https://pypi.org/project/blue-objects/) [![PyPI - Downloads](https://img.shields.io/pypi/dd/blue-objects)](https://pypistats.org/packages/blue-objects)
  built by 🌀 [`blue_options-4.169.1`](https://github.com/kamangir/awesome-bash-cli), based on 🌀 [`blue_objects-5.203.1`](https://github.com/kamangir/blue-objects).


pkgId: 4895b888ba5415180553e18cb04c49e83753f8f8b4090e0798b483b42c43cafd
name: python-blue-options
arch: src
version: 4.166.1
epoch: 0
release: 1
summary: 🌀 options for Bash.
url: https://github.com/kamangir/blue-options
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blue-options-4.166.1-1.src.rpm
checksum_type: sha256
description:
  [![pylint](https://github.com/kamangir/blue-options/actions/workflows/pylint.yml/badge.svg)](https://github.com/kamangir/blue-options/actions/workflows/pylint.yml) [![pytest](https://github.com/kamangir/blue-options/actions/workflows/pytest.yml/badge.svg)](https://github.com/kamangir/blue-options/actions/workflows/pytest.yml) [![PyPI version](https://img.shields.io/pypi/v/blue-options.svg)](https://pypi.org/project/blue-options/) [![PyPI - Downloads](https://img.shields.io/pypi/dd/blue-options)](https://pypistats.org/packages/blue-options)


pkgId: 226a161f087f0c00d411c9298639bba87a28b09ef10d69d64d1a96352d9057b3
name: python-blue-plugin
arch: src
version: 3.179.1
epoch: 0
release: 1
summary: 🌀 a git template for an awesome-bash-cli plugin.
url: https://github.com/kamangir/blue-plugin
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blue-plugin-3.179.1-1.src.rpm
checksum_type: sha256
description:
  [![pylint](https://github.com/kamangir/blue-plugin/actions/workflows/pylint.yml/badge.svg)](https://github.com/kamangir/blue-plugin/actions/workflows/pylint.yml) [![pytest](https://github.com/kamangir/blue-plugin/actions/workflows/pytest.yml/badge.svg)](https://github.com/kamangir/blue-plugin/actions/workflows/pytest.yml) [![bashtest](https://github.com/kamangir/blue-plugin/actions/workflows/bashtest.yml/badge.svg)](https://github.com/kamangir/blue-plugin/actions/workflows/bashtest.yml) [![PyPI version](https://img.shields.io/pypi/v/blue-plugin.svg)](https://pypi.org/project/blue-plugin/) [![PyPI - Downloads](https://img.shields.io/pypi/dd/blue-plugin)](https://pypistats.org/packages/blue-plugin)
  built by 🌀 [`blue_options-4.157.1`](https://github.com/kamangir/awesome-bash-cli), based on 🌀 [`blue_plugin-3.179.1`](https://github.com/kamangir/blue-plugin).


pkgId: d78686bf32a04777da3a2ccae37d1d14e040062b8dd4dec9ffa1284fc01c2411
name: python-blue-stability
arch: src
version: 4.48.1
epoch: 0
release: 1
summary: 🟦 a command interface to stability.ai.
url: https://github.com/kamangir/blue-stability
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blue-stability-4.48.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/blue-stability.svg)](https://pypi.org/project/blue-stability/)


pkgId: 165934ce5d6407b0e750f0648c137fb6089fa1588e066e176e693d34944ac5fd
name: python-blue-yonder
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: Bluesky's Python API for humans.
url: https://github.com/alxfed/blue-yonder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blue-yonder-0.0.11-1.src.rpm
checksum_type: sha256
description:
  Bluesky Python API for humans.
  ```Bash
    pip install blue-yonder
  ```
  Note: the pip package name has a dash `-` between the words.

  Then:
  ```Python


  from blue_yonder import Client
  ```
  Note: the library name has an underscore `_` between the words.
  <br>There are more 'playful' aliases for the `blue_yonder` Client too, namely:
  ```Python
  from blue_yonder import Butterfly

  from blue_yonder import Bird
  ```
  This is because Butterflies and Birds are the main 'clients' of the blue sky of course.


  I didn't want to overload this repository and library with examples; you can use the Template repository with multiple examples, that I consider to be useful. It is located [here](https://github.com/alxfed/butterfly). Just click the 'Use this template' button at the top of the page and create your own repository in your account that you can edit and use the way you deem fit.


pkgId: f8b7d03173ea7bc0f9f894ec68aaa714b876bdea819a4fe0b7f783627f09a1d6
name: python-blue-yonder
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Bluesky Python API for humans.
url: https://github.com/alxfed/blue-yonder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blue-yonder-0.0.6-1.src.rpm
checksum_type: sha256
description:
  Bluesky Python API for humans.
  ```Bash
    pip install blue-yonder
  ```
  Note: the pip package name has a dash `-` between the words.

  Then:
  ```Python

  import blue_yonder as by

  from blue_yonder import Butterfly
  ```
  Note: the library name has an underscore `_` between the words.


  ```Python

  from blue_yonder import Butterfly
  ```


  You can use Template repository with multiple examples located [here](https://github.com/alxfed/butterfly)


pkgId: 63c3271af0d30ff31df4ac1c4ede682107696381eef6875128ac4f3dd8a595a1
name: python-blueapi
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Lightweight bluesky-as-a-service wrapper application. Also usable as a library.
url: https://pypi.org/project/blueapi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueapi-0.6.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/DiamondLightSource/blueapi/main/docs/images/blueapi-logo.svg"
       style="background: none" width="120px" height="120px" align="right">

  [![CI](https://github.com/DiamondLightSource/blueapi/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamondLightSource/blueapi/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/DiamondLightSource/blueapi/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/blueapi)
  [![PyPI](https://img.shields.io/pypi/v/blueapi.svg)](https://pypi.org/project/blueapi)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  Lightweight bluesky-as-a-service wrapper application. Also usable as a library.

  Source          | <https://github.com/DiamondLightSource/blueapi>
  :---:           | :---:
  PyPI            | `pip install blueapi`
  Docker          | `docker run ghcr.io/diamondlightsource/blueapi:latest`
  Documentation   | <https://diamondlightsource.github.io/blueapi>
  Releases        | <https://github.com/DiamondLightSource/blueapi/releases>

  This module wraps [bluesky](https://blueskyproject.io/bluesky) plans and devices
  inside a server and exposes endpoints to send commands/receive data. Useful for
  installation at labs where multiple people may control equipment, possibly from
  remote locations.

  ![concept][]

  The main premise of blueapi is to minimize the boilerplate required to get plans
  and devices up and running by generating an API for your lab out of
  type-annotated plans. For example, take the following plan:

  ```python
      import bluesky.plans as bp
      from blueapi.core import MsgGenerator

      def my_plan(foo: str, bar: int) -> MsgGenerator:
          yield from bp.scan(...)
  ```

  Blueapi's job is to detect this plan and automatically add it to the lab's API
  so it can be invoked easily with a few REST calls.

  <!-- README only content. Anything below this line won't be included in index.md -->

  See https://diamondlightsource.github.io/blueapi for more detailed documentation.

  [concept]: https://raw.githubusercontent.com/DiamondLightSource/blueapi/main/docs/images/blueapi.png

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


pkgId: 087cbc1893f67899a8dae039cb8e913d298a4c93e824613e414c30aa0e041047
name: python-blueapi
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Lightweight bluesky-as-a-service wrapper application. Also usable as a library.
url: https://pypi.org/project/blueapi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueapi-0.6.1-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/DiamondLightSource/blueapi/main/docs/images/blueapi-logo.svg"
       style="background: none" width="120px" height="120px" align="right">

  [![CI](https://github.com/DiamondLightSource/blueapi/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamondLightSource/blueapi/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/DiamondLightSource/blueapi/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/blueapi)
  [![PyPI](https://img.shields.io/pypi/v/blueapi.svg)](https://pypi.org/project/blueapi)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  Lightweight bluesky-as-a-service wrapper application. Also usable as a library.

  Source          | <https://github.com/DiamondLightSource/blueapi>
  :---:           | :---:
  PyPI            | `pip install blueapi`
  Docker          | `docker run ghcr.io/diamondlightsource/blueapi:latest`
  Documentation   | <https://diamondlightsource.github.io/blueapi>
  Releases        | <https://github.com/DiamondLightSource/blueapi/releases>

  This module wraps [bluesky](https://blueskyproject.io/bluesky) plans and devices
  inside a server and exposes endpoints to send commands/receive data. Useful for
  installation at labs where multiple people may control equipment, possibly from
  remote locations.

  ![concept][]

  The main premise of blueapi is to minimize the boilerplate required to get plans
  and devices up and running by generating an API for your lab out of
  type-annotated plans. For example, take the following plan:

  ```python
      import bluesky.plans as bp
      from blueapi.core import MsgGenerator

      def my_plan(foo: str, bar: int) -> MsgGenerator:
          yield from bp.scan(...)
  ```

  Blueapi's job is to detect this plan and automatically add it to the lab's API
  so it can be invoked easily with a few REST calls.

  <!-- README only content. Anything below this line won't be included in index.md -->

  See https://diamondlightsource.github.io/blueapi for more detailed documentation.

  [concept]: https://raw.githubusercontent.com/DiamondLightSource/blueapi/main/docs/images/blueapi.png

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


pkgId: 01f8ce6f2ffcffec8adce4b95995a08a2b967eca2d9cae850ffc85b1aae3c7ee
name: python-blueapps
arch: src
version: 4.14.0
epoch: 0
release: 1
summary: development framework for blueking
url: https://github.com/TencentBlueKing/blueapps
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueapps-4.14.0-1.src.rpm
checksum_type: sha256
description:
  ![blueapps](docs/resource/img/blueapps.png)

  [![license](https://img.shields.io/badge/license-mit-brightgreen.svg?style=flat)](https://github.com/TencentBlueKing/blueapps/blob/master/LICENSE) [![Release Version](https://img.shields.io/badge/release-3.3.3-brightgreen.svg)](https://github.com/TencentBlueKing/blueapps/releases) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/TencentBlueKing/blueapps/pulls)

  > **重要提示**: `master` 分支是开发分支，可能处于 *不稳定或者不可用状态* 。请通过[releases](https://github.com/TencentBlueKing/blueapps/releases) 而非 `master` 去获取稳定的软件包

  蓝鲸Python开发框架Blueapps可以帮助开发人员快速在蓝鲸 PaaS 平台上开发 SaaS 的 `Python 框架` 。该开发框架基于 `Django 框架` 架构，并在此基础上进行扩展，增加蓝鲸系统的特有功能，例如：`身份验证`、`ESB 调用` 及 `模板渲染` 等功能，以便开发者可以更专注于 SaaS 的 `逻辑开发` 。

   本次开源的是蓝鲸Python开发框架Blueapps打包编译环境，执行打包构建后开发人员可以直接基于源码提供的功能进行开发。



  - [快速开始](docs/overview/project_usage.md)
  - [代码目录](docs/overview/project_codes.md)
  - [配置管理](docs/overview/project_config.md)
  - [apigw自动注册](docs/overview/project_apigw_sync.md)
  - [使用说明](https://bk.tencent.com/docs/document/6.0/130/5949)



  - [版本日志](docs/release.md)



  - [蓝鲸论坛](https://bk.tencent.com/s-mart/community)

  - 联系我们，技术交流QQ群：

    社区版QQ交流群：495299374

    蓝鲸运维开发交流群：878501914

    <img src="docs/resource/img/QR-Code.png" align=center style="zoom:67%;" />


  * [BK-CMDB](https://github.com/Tencent/bk-cmdb): 蓝鲸配置平台（蓝鲸 CMDB）是一个面向资产及应用的企业级配置管理平台。
  - [BK-CI](https://github.com/Tencent/bk-ci): 蓝鲸持续集成平台是一个开源的持续集成和持续交付系统，可以轻松将你的研发流程呈现到你面前。
  - [BK-BCS](https://github.com/Tencent/bk-bcs): 蓝鲸容器管理平台是以容器技术为基础，为微服务业务提供编排管理的基础服务平台。
  - [BK-BCS-SaaS](https://github.com/Tencent/bk-bcs-saas): 蓝鲸容器管理平台 SaaS 基于原生 Kubernetes 和 Mesos 自研的两种模式，提供给用户高度可扩展、灵活易用的容器产品服务。
  - [BK-PaaS](https://github.com/Tencent/bk-PaaS): 蓝鲸 PaaS 平台是一个开放式的开发平台，让开发者可以方便快捷地创建、开发、部署和管理 SaaS 应用。
  - [BK-SOPS](https://github.com/Tencent/bk-sops): 标准运维（SOPS）是通过可视化的图形界面进行任务流程编排和执行的系统，是蓝鲸体系中一款轻量级的调度编排类 SaaS 产品。
  - [BK-JOB](https://github.com/Tencent/bk-job): 蓝鲸作业平台(Job)是一套运维脚本管理系统，具备海量任务并发处理能力。


  对于项目感兴趣，想一起贡献并完善项目请参阅[Contributing Guide](docs/CONTRIBUTING.md)。

  [腾讯开源激励计划](https://opensource.tencent.com/contribution) 鼓励开发者的参与和贡献，期待你的加入。



  请查看 [FAQ](docs/faq.md)



  基于 MIT 协议， 详细请参考[LICENSE](LICENSE.txt)


pkgId: 505371c3fca391649b11ac50fadd86413ccc7d0b734417eb2ab773f390f9f77f
name: python-bluebell-akn
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Transforms text to and from Akoma Ntoso
url: https://github.com/laws-africa/bluebell
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluebell-akn-3.1.0-1.src.rpm
checksum_type: sha256
description:
  ![Bluebell icon](https://laws.africa/img/icons/bluebell.png)

  Bluebell is a (fairly) generic Akoma Ntoso 3 parser, supporting all hierarchical elements and multiple document types.

  Bluebell supports the following Akoma Ntoso (AKN) document types:

  * act, bill (hierarchicalStructure)
  * debateReport, doc, statement (openStructure)
  * judgment (judgmentStructure)

  Bluebell tries to walk the line between being expressive and supporting a range of AKN documents and structures,
  while being simple to use and not requiring that authors have an in-depth knowledge of AKN.

  Bluebell will always produce structurally valid Akoma Ntoso, no matter what input is given. It will never refuse to parse
  malformed input. If it does, it's a bug.



  1. Install from pypi: `pip install bluebell-akn`
  2. Create an `AkomaNtosoParser` object with a valid FRBR URI, and parse your text:

  ```python
  from bluebell.parser import AkomaNtosoParser
  from cobalt.uri import FrbrUri
  from lxml import etree

  frbr_uri = FrbrUri.parse("/akn/za/act/2009/1")
  parser = AkomaNtosoParser(frbr_uri)
  xml = parser.parse_to_xml("""
  CHAPTER 1
  1. Section 1
  Some text""", "act")
  print(etree.tostring(xml, encoding='unicode'))
  ```





  These are semi-structured content blocks that are indicated with a keyword. Use the `BODY` keyword
  to indicate where the preface and/or preamble end, and the body starts.

  ```
  PREFACE
    ...

  PREAMBLE
    ...

  BODY
    ...

  CONCLUSIONS
    ...
  ```



  Judgments are broken into various sections which are indicated with a keyword.

  ```
  INTRODUCTION
    ...

  BACKGROUND
    ...

  ARGUMENTS
    ...

  REMEDIES
    ...

  MOTIVATION
    ...

  DECISION
    ...
  ```



  All AKN hierarchical elements are supported.

  **Format**

  ```
  <hier><attribs>
    ...

  <hier><attribs>
    SUBHEADING <subheading>
    ...

  <hier><attribs> <num>
    ...

  <hier><attribs> <num> - <heading>
    ...

  <hier><attribs> - <heading>
    ...
  ```

  * `<hier>` is a hierarchical element keyword or synonym, such as `CHAPTER`, `PART`, `SECTION`, `PARA` etc.
  * `<attribs>` are attributes (optional)
  * `<num>` is an optional number, eg `2` or `2a` or `2(bis)`
  * `<heading>` is an optional heading
  * `<subheading>` is an optional subheading



  The following synonyms are supported for hierarchical elements:

  * `ART` (`ARTICLE`)
  * `CHAP` (`CHAPTER`)
  * `PARA` (`PARAGRAPH`)
  * `SEC` (`SECTION`)
  * `SUBCHAP` (`SUBCHAPTER`)
  * `SUBPARA` (`SUBPARAGRAPH`)
  * `SUBSEC` (`SUBSECTION`)



  A crossheading is a special heading element that can be used between hierarchical elements, without
  creating a new element in the hierarchy.

  ```
  CROSSHEADING <heading>
  ```



  All document types support attachments, which can also be nested. Attachments must come at the end
  of a document.

  The keywords `APPENDIX`, `SCHEDULE` and `ANNEXURE` can also be used instead of `ATTACHMENT`.

  ```
  ATTACHMENT <heading>
    ...

  ATTACHMENT <heading>
    SUBHEADING <subheading>
    ...

  ```

  * `<heading>` (optional) a heading for the attachment
  * `<subheading>` a subheading heading for the attachment





  General number lists that are not part of the hierarchy.

  ```
  ITEMS
    <introductory text>

    ITEM
      SUBHEADING <subheading>
      ...

    ITEM <num>
      ...

    ITEM <num> - <heading>
      ...

    ITEM - <heading>
      ...

    <wrap-up text>

  ```

  * `<introductory text>` is optional plain text before the first item
  * `<num>` is an optional item number, such as `(a)` or `2bis`
  * `<heading>` is an optional item heading
  * `<subheading>` is an optional item subheading
  * `<wrap-up text>` is optional plain text after the last item



  An un-numbered bulleted list that is not part of the hierarchy.

  ```
  BULLETS
    * item 1
    * item 2 with text
      on multiple lines
  ```



  A block quotation. Use the `startQuote` to indicate the quote starting prefix, such as `"`

  ```
  QUOTE<attribs>
    ...

  QUOTE{startQuote "}
    ...
  ```

  * `<attribs>` are attributes (optional)



  A table is made up of rows and cells.

  ```
  TABLE<attribs>
    TR
      TH<attribs>
        A table heading cell

      TC
        A regular table cell

    TR
      TC{colspan 2}
        Cell in the second row that spans columns
  ```

  * `<attribs>` are attributes (optional)



  A special block element for the long title of a legislation document.

  ```
  LONGTITLE <long title>
  ```



  General formatting elements:

  ```
  **bold**
  //italics//
  __underline__
  {{^superscript}}
  {{_subscript}}
  ```



  Abbreviations include the full expansion of the abbreviation using the `title` attribute.

  ```
  {{abbr{title Akoma Ntoso} AKN}}
  ```



  Editorial remarks are for content not originally included by the document author. Editorial remarks can
  contain other inline elements, such as links and formatting. Remarks may span multiple lines.

  ```
  {{*remark content}}

  A {{*remark may
  span

  multiple lines.}}
  ```



  Emphasis is not always the same as italics and may be formatted differently.

  ```
  {{em<attribs> text}}
  ```

  * `<attribs>` are attributes (optional)



  Footnotes are made up of two components: the footnote marker and the footnote content. The marker
  is often in superscript `{{^...}}` but this not required.

  The marker is indicated with `{{FOOTNOTE <symbol>}}`.

  * `<symbol>` is the footnote symbol, such as `*` or `1`.

  The footnote content comes after the line with the marker, at the same indent level. The symbols must match.

  ```
  This sentence includes the {{^{{FOOTNOTE *}}}} marker.

  FOOTNOTE *
    This is the footnote content.
  ```



  A generic inline element must be identified with the `name` attribute.

  ```
  {{inline{name <name>} text}}
  ```

  * `<name>` the inline name (required)



  Embed an image as follows:

  ```
  {{IMG <src> <description>}}
  ```

  * `<src>` is the relative or absolute URL to the image file
  * `<description>` is the alternate text that describes the image



  References are for internal and external links.

  ```
  {{>https://example.com link text}}
  ```



  A defined term. This usually has the `refersTo` attribute.

  ```
  {{term<attribs> term}}

  {{term{refersTo #special-term} special term}}
  ```

  * `<attribs>` are attributes (optional)



  When `<attribs>` is supported, it is a list of attributes to be applied to the XML element.
  Attributes are `<name> <value>` pairs. Multiple attributes are separate with `|`.

  ```
  {attr value}

  {attr1 value1|attr2 value2}
  ```

  The `class` attribute can be added using dot-notation before the attributes:

  ```
  .class1.class2{attr value}
  ```

  This is equivalent to:

  ```
  {class class1 class2|attr value}
  ```





  Use the parser from Python as follows:

  ```python
  from lxml import etree
  import json
  from bluebell.parser import AkomaNtosoParser

  parser = AkomaNtosoParser()


  xml = parser.parse_to_xml(text, 'act')
  print(etree.tostring(xml, pretty_print=True, encoding='unicode'))


  tree = parser.parse(text, 'act')
  print(json.dumps(tree.to_dict()))
  ```



  In general, see `bluebell --help`

  Parse an `act` in `act.txt` and output pretty XML: `bluebell /za/act/2020/1 act act.txt --pretty`

  Use `--json` for intermediat json output.



  The document type (act, judgment, etc.) determines the top-level elements of the text. Most other elements (hierarchical containers, tables, etc.)
  are common to all document types.

  Here's an example act:

      PREFACE

      This is in the preface

      PREAMBLE

      This is in the preamble

      BODY

      Introductory text in the body.

      SECTION 1.

        Text in section one, with some list items:

        SUBSECTION (a)

          cheese

        SUBSECTION (b)

          fish, both:

          SUBSECTION (i)

            fresh, and

          SUBSECTION (ii)

            tinned.

      PART 1 - The First Part
        SUBHEADING Very exciting

        SECTION 2.

          This is the second section inside part 1.

      SCHEDULE - First Schedule
        SUBHEADING With a subheading

        Text of the schedule

  Key points:

  * Keywords are in ALL CAPS, so that it's harder to mistake them for actual text
  * Hierarchical elements all follow the same pattern, and support a number, heading and subheading, all of which are optional
  * Content inside a hierarchical element is always nested
  * Content inside a block element at the top level is usually nested, but Bluebell is forgiving and
    makes a best effort if you don't nest it.
  * If Bluebell finds something it doesn't understand, it includes it as text and continues.



  The parser produces a dict (Python) parse tree, which is later transformed into XML.
  This intermediate step makes it easier to adapt the parser's output it AKN's sometimes finnicky requirements.

  You can see an example of this structure by running `bluebell act act.txt --json`

  ```
  {
    type: 'type of the element, such as "hier", "block" etc.',
    name: 'name of the element, such as "body", "part" or "p",
    attribs: {
      key1: value1,
      key2: value2,
    },
    children: [],
  }
  ```

  Valid types:

  * `element`: simple element
  * `hier`: hierarchical element
  * `block`: block element
  * `content`: content element, such as `p` or `listIntroduction`
  * `inline`: inline element, such as `b` or `ref`
  * `text`: plain text
  * `marker`: a marker element that cannot contain children, such as `img`



  Most elements can contain children. This is an array of elements.

  These elements cannot contain children: `text`, `marker`.



  The content of a text element is in the `value` attribute.

  An element that contains a single, pure-text child, can instead have a `text` attribute containing the equivalent of the `value`
  attribute of the text element.



  Inline elements such as `b` and `term` may have other inline or text children,
  or a single `text` attribute.



  Block elements cannot have `hier` children.

  * `num`: number; inline element



  * `heading`: heading element; a block element
  * `subheading`: subheading element; a block element
  * `num`: number; inline element



  Footnotes are treated specially because they are a subflow element that appears inline.
  The are split into two parts: a reference to the footnote inline, and the footnote content:

      This text[++FN 1++] has a footnote.

      FOOTNOTE 1

        the content of the footnote

  When converting the parse tree into XML, the footnote content must be inserted into
  the point where it is referenced. This is done by post-processing the XML. A special non-AKN
  `<displaced name="footnote" marker="1">...</displaced>` element is inserted in the
  XML where the footnote content appears. The reference to the footnote inline is an
  appropriate `authorialNote` element with a `displaced="footnote"` attribute.

  Post-processing code then matches the `<displaced>` element with its `<authorialNote>`
  using the name and marker, moves the children of the `displaced` into the `authorialNote`,
  and removes the `displaced` element.



  ```javascript
  {
    type: 'hier',
    name: 'chapter',
    num: '1',
    heading: 'Definitions and fundamental principles',
    children: [{
      type: 'hier',
      name: 'section',
      num: '1.',
      heading: 'Definitions',
      children: [{
        type: 'inline',
        name: 'p',
        text: 'In this By-law, unless the context indicates otherwise -',
      }, {
        type: 'inline',
        name: 'p',
        text: '"Air Quality" means:',
      }, {
        type: 'block',
        name: 'list',
        children: [{
          type: 'block',
          name: 'item',
          num: '(a)',
          children: [{
            type: 'inline',
            name: 'p',
            children: [{
              type: 'text',
              value: 'something with '
            }, {
              type: 'inline',
              name: 'b',
              text: 'bold',
            }, {
              type: 'text',
              value: ' in it.'
            }],
          }],
        }, {
          type: 'block',
          name: 'item',
          num: '(b)',
          children: [{
            type: 'inline',
            name: 'p',
            children: [{
              type: 'text',
              value: 'text with a',
            }, {
              type: 'marker',
              name: 'eol',
            }, {
              type: 'text',
              value: 'newline in it.',
            }],
          }],
        }],
      }],
    }],
  }
  ```



  1. We use a version of `canopy` from github, so clone it into the same directory as this directory: `git clone https://github.com/jcoglan/canopy.git`
  2. Build canopy: `cd canopy; npm install; make; cd ..`
  3. Build grammar changes with `make`, which runs our Makefile to compile the grammar
  4. Run tests with: `python -m unittest`



  1. Update the version by changing the `__version__` variable in [bluebell/__init__.py](bluebell/__init__.py)
  2. Commit your changes and push to the master branch on GitHub
  3. Create a release in GitHub and it will automatically be pushed to PyPi



  Copyright 2020 Laws.Africa.

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.


pkgId: 84e38dc222c6840913aaf32545d810a314d3b8be1680716090eef6b031560bca
name: python-bluebelt
arch: src
version: 0.2.20
epoch: 0
release: 1
summary: Tools for HR analytics.
url: https://www.maanrijp.nl
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluebelt-0.2.20-1.src.rpm
checksum_type: sha256
description:
  Tools for HR Analytics

  Copyright (C) 2020 Arvid Hahné

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.


  Bluebelt is a collection of python tools that can be used in HR analytics projects. The package is far from complete but it is in active development.


  The package is highly dependent on Pandas. There a two ways to use the functions available.

  ... to be continued ...


pkgId: ff0c1d03b670adacd54a133a65480b140e8b9cba3ce1ab39192a54e454385b47
name: python-bluecast
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: A lightweight and fast automl framework
url: https://github.com/ThomasMeissnerDS/BlueCast
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluecast-1.6.2-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/ThomasMeissnerDS/BlueCast/branch/main/graph/badge.svg?token=XRIS04O097)](https://codecov.io/gh/ThomasMeissnerDS/BlueCast)
  [![Codecov workflow](https://github.com/ThomasMeissnerDS/BlueCast/actions/workflows/workflow.yaml/badge.svg)](https://github.com/ThomasMeissnerDS/BlueCast/actions/workflows/workflow.yaml)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![pydocstyle](https://img.shields.io/badge/pydocstyle-enabled-AD4CD3)](http://www.pydocstyle.org/en/stable/)
  [![Documentation Status](https://readthedocs.org/projects/bluecast/badge/?version=latest)](https://bluecast.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/bluecast.svg)](https://pypi.python.org/pypi/bluecast/)
  [![Optuna](https://img.shields.io/badge/Optuna-integrated-blue)](https://optuna.org)
  [![python](https://img.shields.io/badge/Python-3.9-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
  [![python](https://img.shields.io/badge/Python-3.10-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

  ![BlueCast](docs/source/bluecast_dragon_logo_5.jpeg)

  A lightweight and fast auto-ml library, that helps data scientists
  tackling real world problems from EDA to model explainability
  and even uncertainty quantification.
  BlueCast focuses on a few model architectures (on default Xgboost
  only) and a few preprocessing options (only what is
  needed for Xgboost). This allows for a much faster development
  cycle and a much more stable codebase while also having as few dependencies
  as possible for the library. Despite being lightweight in its core BlueCast
  offers high customization options for advanced users. Find
  the full documentation [here](https://bluecast.readthedocs.io/en/latest/).

  Here you can see our test coverage in more detail:

  [![Codecov sunburst](https://codecov.io/gh/ThomasMeissnerDS/BlueCast/graphs/sunburst.svg?token=XRIS04O097)](https://codecov.io/gh/ThomasMeissnerDS/BlueCast/graphs/sunburst.svg?token=XRIS04O097)

  <!-- toc -->

  * [Philosophy](#philosophy)
  * [What BlueCast has to offer](#what-bluecast-has-to-offer)
    * [Basic usage](#basic-usage)
    * [Convenience features](#convenience-features)
    * [Kaggle competition results and example notebooks](#kaggle-competition-results-and-example-notebooks)
  * [About the code](#about-the-code)
    * [Code quality](#code-quality)
    * [Documentation](#documentation)
    * [How to contribute](#how-to-contribute)
    * [Supports us](#supports-us)
    * [Meta](#meta)

  <!-- tocstop -->



  There are plenty of excellent automl solutions available.
  With BlueCast we don't follow the usual path ("Give me your data, we return the
  best model ensemble out of X algorithms"), but have the real world data
  scientist in mind. Our philosophy can be summarized as such:

  * automl should not be a black box
  * automl shall be a help rather than a replacement
  * automl shall not be a closed system
  * automl should be easy to install
  * explainability over another after comma digit in precision
  * real world value over pure performance

  We support our users with an end-to-end toolkit, allowing fast and rich EDA,
  modelling at highest convenience, explainability, evaluation and even
  uncertainty quantification.





  ```sh
  from bluecast.blueprints.cast import BlueCast

  automl = BlueCast(
          class_problem="binary",
      )

  automl.fit(df_train, target_col="target")
  y_probs, y_classes = automl.predict(df_val)


  y_probs = automl.predict_proba(df_val)
  ```



  Despite being a lightweight library, BlueCast also includes some convenience
  with the following features:

  * rich library of EDA functions to visualize and understand the data
  * plenty of customization options via an open API
  * inbuilt uncertainty quantification framework (conformal prediction)
  * hyperparameter tuning (with lots of customization available)
  * automatic feature type detection and casting
  * automatic DataFrame schema detection: checks if unseen data has new or
    missing columns
  * categorical feature encoding (target encoding or directly in Xgboost)
  * datetime feature encoding
  * automated GPU availability check and usage for Xgboost
    a fit_eval method to fit a model and evaluate it on a validation set
    to mimic production environment reality
  * functions to save and load a trained pipeline
  * shapley values
  * ROC AUC curve & lift chart
  * warnings for potential misconfigurations

  The fit_eval method can be used like this:

  ```sh
  from bluecast.blueprints.cast import BlueCast

  automl = BlueCast(
          class_problem="binary",
      )

  automl.fit_eval(df_train, df_eval, y_eval, target_col="target")
  y_probs, y_classes = automl.predict(df_val)
  ```

  It is important to note that df_train contains the target column while
  df_eval does not. The target column is passed separately as y_eval.



  Even though BlueCast has been designed to be a lightweight
  automl framework, it still offers the possibilities to
  reach very good performance. We tested BlueCast in Kaggle
  competitions to showcase the libraries capabilities
  feature- and performance-wise.

  * ICR top 20% finish with over 6000 participants ([notebook](https://www.kaggle.com/code/thomasmeiner/icr-bluecast-automl-almost-bronze-ranks))
  * An advanced example covering lots of functionalities ([notebook](https://www.kaggle.com/code/thomasmeiner/ps3e23-automl-eda-outlier-detection/notebook))
  * PS3E23: Predict software defects top 12% finish ([notebook](https://www.kaggle.com/code/thomasmeiner/ps3e23-automl-eda-outlier-detection?scriptVersionId=145650820))
  * PS3E25: Predict hardness of steel via regression ([notebook](https://www.kaggle.com/code/thomasmeiner/ps3e25-bluecast-automl?scriptVersionId=153347618))
  * PS4E1: Bank churn top 13% finish ([notebook](https://www.kaggle.com/code/thomasmeiner/ps4e1-eda-feature-engineering-modelling?scriptVersionId=158121062))
  * A comprehensive guide about BlueCast showing many capabilities ([notebook](https://www.kaggle.com/code/thomasmeiner/ps4e3-bluecast-a-comprehensive-overview))
  * BlueCast using a custom Catboost model for quantile regression
  and adding conformal prediction ([notebook](https://www.kaggle.com/code/thomasmeiner/bluecast-has-conformal-prediction))
  * 26th place in the Kaggle 24h "AutoMl" GrandPrix July 2024 blitz competition ([notebook](https://www.kaggle.com/code/thomasmeiner/automl-grand-prix-bluecast-26th-place-solution))

  Please note that some notebooks ran older versions of BlueCast and
  might not be compatible with the most recent version anymore.





  To ensure code quality, we use the following tools:

  * various pre-commit libraries
  * strong type hinting in the code base
  * unit tests using Pytest

  For contributors, it is expected that all pre-commit and unit tests pass.
  For new features it is expected that unit tests are added.



  Documentation is provided via [Read the Docs](https://bluecast.readthedocs.io/en/latest/)
  On GitHub we offer multiple ReadMes to cover all aspects of working
  with BlueCast, covering:

  * [Installation](docs/source/Installation.md)
  * [EDA](docs/source/EDA.md)
  * [Basic usage](docs/source/Basic%20usage.md)
  * [Customize training settings](docs/source/Customize%20training%20settings.md)
  * [Feature engineering](docs/source/Feature%20engineering.md)
  * [Customizing configurations and objects](docs/source/Customizing%20configurations%20and%20objects.md)
  * [Model evaluation](docs/source/Model%20evaluation.md)
  * [Error analysis](docs/source/Error%20analysis.md)
  * [Model explainability (XAI)](docs/source/Model%20explainability%20(XAI).md)
  * [Uncertainty quantification](docs/source/Uncertainty%20quantification.md)
  * [Monitoring](docs/source/Monitoring.md)



  Contributions are welcome. Please follow the following steps:

  * Get in touch with me (i.e. via LinkedIn) if longer contribution is of interest
  * Create a new branch from develop branch
  * Add your feature or fix
  * Add unit tests for new features
  * Run pre-commit checks and unit tests (using Pytest)
  * Adjust the `docs/source/index.md` file
  * Copy paste the content of the `docs/source/index.md` file into the
    `README.md` file
  * Push your changes and create a pull request

  If library or dev dependencies have to be changed, adjust the pyproject.toml.
  For readthedocs it is also requited to update the
  `docs/srtd_requirements.txt` file. Simply run:

  ```sh
  poetry export --with dev -f requirements.txt --output docs/rtd_requirements.txt
  ```

  If readthedocs will be able to create the documentation can be tested via:

  ```sh
  poetry run sphinx-autobuild docs/source docs/build/html
  ```

  This will show a localhost link containing the documentation.



  Being a small open source project we rely on the community. Please
  consider giving us a GitHb star and spread the word. Also your feedback
  will help the project evolving.



  Creator: Thomas Meißner – [LinkedIn](https://www.linkedin.com/in/thomas-mei%C3%9Fner-m-a-3808b346)


pkgId: afb960616d4aabbc76e900b148a935693fdc2f5b776177e2cef82582bd5568b0
name: python-bluecat-libraries
arch: src
version: 24.3.1
epoch: 0
release: 1
summary: Modules for working with BlueCat products.
url: https://docs.bluecatnetworks.com
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluecat-libraries-24.3.1-1.src.rpm
checksum_type: sha256
description:
  Modules for working with products from BlueCat Networks.
  The Python clients in this package provide access to the following BlueCat HTTP APIs:
  -   Address Manager RESTful v2 API (9.5)
  -   Address Manager Legacy REST v1 API (9.3, 9.4, 9.5)
  -   Address Manager Failover API
  -   DNS Edge API
  -   Micetro REST API
      BlueCat strongly recommends using the RESTful v2 API instead of the Legacy v1 API.
      The RESTful v2 API strictly adheres to HTTP 1.1 constraints as detailed in RFC 2616,
      and allows for cleaner, more understandable code.
  The examples below illustrate how to use the Address Manager RESTful v2 API and Legacy v1
  API to fetch BlueCat Address Manager (BAM) configurations.


pkgId: 9d80680d69df27ec527acbfe05042f3b3ee99cfba92b36ad47ba08c9e9b1106f
name: python-bluecellulab
arch: src
version: 2.6.36
epoch: 0
release: 1
summary: Biologically detailed neural network simulations and analysis.
url: https://github.com/BlueBrain/BlueCelluLab
rpm_license: Apache2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluecellulab-2.6.36-1.src.rpm
checksum_type: sha256
description:
  +----------------+------------+
  | Latest Release | |pypi|     |
  +----------------+------------+
  | Documentation  | |docs|     |
  +----------------+------------+
  | License        | |license|  |
  +----------------+------------+
  | Build Status 	 | |tests|    |
  +----------------+------------+
  | Coverage       | |coverage| |
  +----------------+------------+
  | Gitter         | |gitter|   |
  +----------------+------------+
  | Paper          | |joss|     |
  +----------------+------------+
  | Zenodo         | |zenodo|   |
  +----------------+------------+
  The Blue Brain Cellular Laboratory is designed for simulations and experiments on individual cells or groups of cells.
  Suitable use cases for BlueCelluLab include:
  * Scripting and statistical analysis for single cells or cell pairs.
  * Lightweight, detailed reporting on specific state variables after simulation.
  * Developing synaptic plasticity rules.
  * Validating dynamics of synaptic properties.
  * Automating in-silico whole-cell patching experiments.
  * Debugging, both scientifically and computationally.


pkgId: d43b18905eb82d7a98755f64c1170987891ac99f54a68086473969b981c23d5b
name: python-bluecon
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Library for connecting to Fermax Blue supported doorbells
url: https://bluecon.afonsogarcia.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluecon-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Library for connecting to Fermax Blue supported doorbells.



  * Fermax Veo XS WiFi (9449)



  ```sh
  pip install bluecon
  ```



  I'd like to thank all contributors of [push_receiver](https://github.com/olijeffers0n/push_receiver) and its many forks for provinding a library that can receive push notifications from Firebase. This is the essencial part of how Fermax Blue works in terms of receiving the doorbell rings and without it this project would be close to pointless. This library is included with some minor changes in this repo.


pkgId: 998dc22b4ed80ede2458be050b9dd3e2dfcd43cb5b65e04234cd81c92077e727
name: python-bluecurrent-api
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A wrapper for the Blue Current websocket api
url: https://github.com/bluecurrent/HomeAssistantAPI
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluecurrent-api-1.2.3-1.src.rpm
checksum_type: sha256
description:
  <b>The methods validate_token and get_email are stand-alone and are to be used <u>before</u> connecting to the websocket with connect().</b>
  <br>

  - Validates the given token.


pkgId: 77c114366b923df830d08571ee374e6d437390f5d49da547b37143036bed8ec4
name: python-blueice
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Build Likelihoods Using Efficient Interpolations from monte-Carlo generated Events
url: https://github.com/JelleAalbers/blueice
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueice-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Source code: `https://github.com/JelleAalbers/blueice`
  Documentation: `http://blueice.readthedocs.io/en/latest/index.html`


pkgId: a15bfae40cdd463c015a54ad14ca7cb5a52b9283345f03a4b21228b8c7132886
name: python-bluemaestro-ble
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: bluemaestro BLE devices
url: https://github.com/bluetooth-devices/bluemaestro-ble
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluemaestro-ble-0.2.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bluetooth-devices/bluemaestro-ble/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/bluetooth-devices/bluemaestro-ble/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://bluemaestro-ble.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/bluemaestro-ble.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/bluetooth-devices/bluemaestro-ble">
      <img src="https://img.shields.io/codecov/c/github/bluetooth-devices/bluemaestro-ble.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/bluemaestro-ble/">
      <img src="https://img.shields.io/pypi/v/bluemaestro-ble.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/bluemaestro-ble.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/bluemaestro-ble.svg?style=flat-square" alt="License">
  </p>

  bluemaestro BLE devices



  Install this via pip (or your favourite package manager):

  `pip install bluemaestro-ble`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: 42c313b67607c64fb74b7dc4fd666936c99bba642a1f29da9d30c6aa67982581
name: python-bluemax
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://bitbucket.org/blueshed/bluemax/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluemax-0.2.7-1.src.rpm
checksum_type: sha256
description:
  procedures: tests.foo
  services: tests.foo.services
  REDIS_URL: redis://localhost
  ```
  Then run a worker in one terminal
  and a server in the another.
  ```
  bluemax run.worker -c conf.yml
  ```
  and
  ```
  bluemax run.services -c conf.yml
  ```
  and
  ```
  bluemax run.server -c conf.yml
  ```
  Now go to http://localhost:8080 and add some numbers.
  To build your own project try:
  ```
  bluemax sidney olive
  ```
  You can use any name for your module. It will create extension points for logs,
  settings, urls and a base procedures modules. bluemax will look for your
  procedures.__all__ in the module you pass in.


pkgId: 2c1c7fa9c0ad2673edb9bb3bd6fdbd0a437f3c55a285e0d43b427896a38b483b
name: python-bluemoss
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: bluemoss enables you to easily scrape websites.
url: https://github.com/LucaTabone/bluemoss
rpm_license: APACHE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluemoss-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <h1 align="center">bluemoss</h1>
    <h3 align="center">scrape the web</h3>
    <br>
    <p align="center">
      <a href="https://github.com/grantjenks/blue">
          <img src="https://camo.githubusercontent.com/dbdbcf26db37abfa1f2ab7e6c28c8b3a199f2dad98e4ef53a50e9c45c7e4ace8/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f636f64652532307374796c652d626c75652d626c75652e737667" alt="Code style: blue"/>
      </a>
      <img src="https://img.shields.io/github/actions/workflow/status/LucaTabone/bluemoss/test.yml?branch=main&label=tests" alt="GitHub Workflow Status (main)"/>
      <a href="https://LucaTabone.github.io/bluemoss/htmlcov/index.html">
          <img src="https://img.shields.io/codecov/c/github/LucaTabone/bluemoss" alt="Coverage">
      </a>
      <img src="https://img.shields.io/pypi/pyversions/bluemoss" alt="Supported python versions"/>
      <img src="https://img.shields.io/pypi/v/bluemoss" alt="Latest package version"/>
    </p>
  </p>

  <br>
  <hr>



  ```bash
  pip install bluemoss
  ```

  <hr>


  <h4>
      <a href="https://bluemoss.readthedocs.io/en/latest/">Read the docs</a>
  </h4>

  <hr>




  ```python
  from bluemoss import Node, scrape


  node = Node('a')  # extract the text contained in the first a-tag

  scrape(node, YOUR_HTML)
  ```
  <br>
  With **bluemoss**, you create a `Node` object to scrape data from any website.
  Imagine that `Node` object to be like a recipe 👩‍🍳 which describes what to scrape from which tags,
  and how to transform and structure the scraped data it into the format you need.
  <br>
  <br>
  **bluemoss** uses XPath 1.0 to locate html tags. If you are new to XPath, no problem — <a href="chat.openai.com">ChatGPT</a>
  has got your back.
  <br>

  <hr>



  This section will show you how can to scrape the web with **bluemoss**.
  <br>
  For all examples that follow, we are going to scrape the html document below.

  ```html
  <html>
      <body>
          <li>
              <a href="/portfolio?company=apple">
                  Apple
              </a>
              <div class="location_us">
                  <p>Cupertino</p>
              </div>
          </li>

          <li>
              <a href="/portfolio?company=google">
                  Google
              </a>
              <div class="location_us">
                  <p>Mountain View</p>
              </div>
          </li>

          <li>
              <a href="/portfolio?company=deepmind">
                  DeepMind
              </a>
              <div class="location_uk">
                  <p>London</p>
              </div>
          </li>
      </body>
  </html>
  ```

  <br>
  <hr>

  **Example 1** - Scrape the text in the first **a** tag.

  The **Node** object below instructs the **scrape** function to find the first *a*-tag and extract the text it contains.

  ```python
  from bluemoss import Node, scrape


  node = Node('a')

  scrape(node, HTML) == 'Apple'
  ```

  <hr>
  <br>

  **Example 2** - Scrape the **second** company headquarters which are located in the US

  ```python
  node = Node('div[contains(@class, "location_us")]', filter=1)

  scrape(node, HTML) == 'Mountain View'
  ```

  `Pro Tip: Learning XPath is easy and fast with ChatGPT.`

  This example introduces the **filter** argument which determines which of those tag(s) that match the xpath locator
  will be scraped. The default value for the **filter** arg is 0 (index 0), which will scrape the very first
  tag that matches the given xpath. Our goal for this example was to extract the text of the second tag (index 1)
  that matches our xpath, therefor we set **filter = 1**.

  <hr>
  <br>

  **Example 3** - Scrape **ALL** company headquarters which are located in the US

  ```python
  node = Node('div[contains(@class, "location_us")]', filter=None)

  scrape(node, HTML) == ['Cupertino', 'Mountain View']
  ```

  Setting **filter=None** will filter for all tags matched against the given xpath.

  <hr>
  <br>

  **Example 4** - Scrape the first and third company names.

  ```python
  Node('a', filter=[0, 2])

  scrape(node, HTML) == ['Apple', 'DeepMind']
  ```

  In this example we set the **filter** arg to a list of ints.
  Those int values refer to the first and third index (0 and 2).

  <hr>
  <br>

  **Example 5** - Scrape all company names, but exclude the first one.

  The expected scrape result is

  ```python
  ['Google', 'DeepMind']


  ```

  <br>
  Below are a couple of valid solutions, and the first one is the most recommended one,
  since it keeps the arguments provided to the Node object as simple as possible:

  ```python


  from bluemoss import Node, Range


  Node('a', filter=Range(1))


  ```

  ```python



  Node('li//a', filter=Range(1))


  ```

  ```python


  Node('a', filter=[1, 2])
  ```

  ```python


  Node('a', filter=Range(1, 3))




  ```

  <hr>
  <br>

  **Example 6** - Scrape all company names from index 1 onwards in reverse order.

  The expected scrape result is

  ```python
  ['DeepMind', 'Google']
  ```

  <br>

  ```python


  Node('a', filter=Range(1, reverse=True))  # set reverse to True
  ```

  ```python


  Node('a', filter=Range(1), transform=lambda res: res[::-1])  # use transform arg
  ```

  The first two examples simply set the **reverse** arg of the Range object to True.
  The last example uses a different approach. It introduces the **transform** arg of the **Node** class.

  The transform function is the function being executed after

  -  the tags were matched with the given xpath
  -  the matched tags were further filtered using the **Node.filter** arg

  `Pro Tip: The transform-function defines the last step in computing the scrape-result of a Node object.`

  <hr>
  <br>

  **Example 7** - Scrape the last two company names and store the result **in a dict** under the key 'companies'

  ```python
  Node('a', filter=[-2, -1], key='companies')

  scrape(node, HTML) == {'companies': ['Google', 'DeepMind']}
  ```

  In the example above we provide the indexes -2 and -1 to the filter-list as those indices represent the last
  two elements in a Python list.

  <hr>
  <br>

  **Example 8** - Scrape the first company name and store the result **in a dict** under the key 'companies'

  ```python
  Node('a', key='companies')

  scrape(node, HTML) == {'companies': 'Apple'}
  ```

  <hr>
  <br>

  **Example 9** - Scrape the first company-id.

  Let us first define a helper function that will receive the href-value as an argument and return the company id:

  ```python


  def get_company_id(href: str) -> str:
      return href.split('=')[-1]
  ```
  <br>

  ```python


  from src.bluemoss import Node, Ex


  Node('a', extract=Ex.HREF, transform=get_company_id)



  ```

  ```python


  Node('a', extract='href', transform=get_company_id)


  ```

  ```python


  Node('a/@href', transform=get_company_id)


  ```

  <hr>
  <br>

  **Example 10 - Advanced Scraping** - Scrape the name and headquarters of every company.

  The expected result:
  ```python
  [
      ['Apple', 'Cupertino'],
      ['Google', 'Mountain View'],
      ['DeepMind', 'London']
  ]
  ```

  <br>

  ```python

  Node(
      'li',  # match 'li' tags
      filter=None,  # scrape all the matched 'li' tags
      nodes=[
          Node('a'),  # within the 'li' tag, match the first 'a' tag and extract the text
          Node('p')  # within the 'li' tag, match the first 'p' tag and extract the text
      ]
  )
  ```

  `Pro Tip: The **nodes** arg let's you scrape multiple different tags within the same parent tag.`

  <hr>
  <br>

  **Example 11 - Advanced Scraping** -
  Scrape the name and headquarters of every company. The result shall be a list of dicts.


  The expected result:
  ```python
  [
      {'name': 'Apple', 'location': 'Cupertino'},
      {'name': 'Google', 'location':  'Mountain View'},
      {'name': 'DeepMind', 'location':  'London'}
  ]
  ```

  <br>

  ```python


  Node(
      'li',
      filter=None,
      nodes=[
          Node('a', key='name'),
          Node('p', key='location')
      ]
  )
  ```

  `Pro Tip: All Nodes in a nodes list either define the 'key' arg or none of them do.`

  <hr>
  <br>

  **Example 12 - Advanced Scraping** - In this last example, we want to scrape the name and location of every company,
  as well as the total amount of companies located in the US and UK. We also want to store the scraped data
  not in a dict or list as we did in the previous examples, but instead want to store the data in dataclass instances.

  **Info** - The code snippet below shows that we assume a dataclass called **Companies** in which we will store the
  entire scrape-result. The expected result also assumes, that the **Companies** instance exposes two properties
  **dict** and **json**

  ```python


  companies: Companies = scrape(node, HTML)

  companies.dict == {
      'companies': [
          {'name': 'Apple', 'location': 'Cupertino'},
          {'name': 'Google', 'location': 'Mountain View'},
          {'name': 'DeepMind', 'location': 'London'},
      ],
      'amount_uk_companies': 1,
      'amount_us_companies': 2,
      'amount_companies': 3
  }

  companies.json == """{
      "companies": [
          {
              "name": "Apple",
              "location": "Cupertino"
          },
          {
              "name": "Google",
              "location": "Mountain View"
          },
          {
              "name": "DeepMind",
              "location": "London"
          }
      ],
      "amount_uk_companies": 1,
      "amount_us_companies": 2,
      "amount_companies": 3
  }"""
  ```

  ```python


  from dataclasses import dataclass
  from bluemoss import Node, Jsonify


  @dataclass
  class Company(Jsonify):
      name: str
      location: str


  @dataclass
  class Companies(Jsonify):
      companies: list[Company]
      amount_uk_companies: int
      amount_us_companies: int

      @property
      def amount_companies(self) -> int:
          return self.amount_us_companies + self.amount_uk_companies

      @property
      def dict(self):
          return super().dict | {'amount_companies': self.amount_companies}


  Node(
      target=Companies,
      nodes=[
          Node(
              'li',
              filter=None,     # makes sure to filter all matched 'li' tags
              key='companies', # will store the scrape-result as a dict under the key 'companies'
              target=Company,  # the data scraped from every 'li' tag will be transformed into a 'Company' instance
              nodes=[          # every 'Company' instance will be initialized with the parameters 'name' and 'location'
                  Node('a', key='name'), # extracts the text from the 'li/a' tag and stores it in the Company.name parameter
                  Node('p', key='location')  # extracts the text from the 'li/p' tag and stores it in the Company.location parameter
              ]
          ),
          Node(
              "div[@class='location_uk']",  # finds all 'div' tags whose class property contains the text 'location_uk'
              filter=None,                  # filter all matched tags
              key='amount_uk_companies',    # stores the result in the Companies.amount_uk_companies parameter
              transform=lambda companies: len(companies) # The initial result is a list (due to filter=None) and it
                                                         
                                                         
          ),
          Node(
              "div[@class='location_us']",
              filter=None,
              key='amount_us_companies',
              transform=lambda companies: len(companies)
          )
      ]
  )
  ```

  The solution in the code snippet introduces two new things:
  - The **Node.target** parameter allows us to specify what class or dataclass to use in order
  to store the data scraped in the **Node.nodes** list. If a Node instance sets a **target**, then all instances in
  Node.nodes must set their **key** parameter and every key must map to one of the init parameters of **Node.target**.
  - The **Jsonify** class exposes the two properties **dict** and **json**. It therefor makes it easy transform the
  scraped data stored in dataclass instances into a Python dict or json string.

  <br>

  `Pro Tip: The Jsonify class will exclude any parameters starting with an underscore "_" from appearing in the return of
  the .dict and .json properties. This enables us to hide certain parameters from appearing in those returns.`

  <br>

  - **type safety** - Dataclass instances as used in this example enforce typed parameters.
  - **properties** - Sometimes we want our data transformations to take place inside the dataclass, e.g. through properties. Properties provide a simple way to derive data from the instance parameters of a class instance. By moving the data transformation step from the **Node.transform** parameter to a **dataclass property**, we make the transformation explicitly available to the dataclass.
  - **post_init** - The __post_init__ method that is available in Python dataclasses is yet another nice step to manipulate the instance parameters and therefore move the data transformation step partially or as a whole from the **Node.transform** parameter to the __post_init__ method of the dataclass.


  <br>
  <hr>




  - Linux
  - MacOS
  - Windows

  <br>
  <hr>




  - 3.9
  - 3.10
  - 3.11
  - 3.12

  <br>
  <hr>




  - Apache 2.0

  <br>
  <hr>


pkgId: ac2a2629b3ab72bb4a6c7d9ab30cc3dd7736e087efa0b9e1262bb26221caa086
name: python-blueness
arch: src
version: 3.82.1
epoch: 0
release: 1
summary: 🌀 the blueness of ai.
url: https://github.com/kamangir/blueness
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueness-3.82.1-1.src.rpm
checksum_type: sha256
description:
  [![pylint](https://github.com/kamangir/blueness/actions/workflows/pylint.yml/badge.svg)](https://github.com/kamangir/blueness/actions/workflows/pylint.yml) [![pytest](https://github.com/kamangir/blueness/actions/workflows/pytest.yml/badge.svg)](https://github.com/kamangir/blueness/actions/workflows/pytest.yml) [![PyPI version](https://img.shields.io/pypi/v/blueness.svg)](https://pypi.org/project/blueness/) [![PyPI - Downloads](https://img.shields.io/pypi/dd/blueness)](https://pypistats.org/packages/blueness)


pkgId: 8dbabf8ea4002dc80e9395f18140e25d0bc4c6675b838095f85793c58dd3334d
name: python-blueprint-environments
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Set of tools to manage environments
url: https://pypi.org/project/blueprint-environments/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueprint-environments-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This README provides an overview of the environment configurations defined in `environments/core.py`.



  The `Environment` class is defined to represent different deployment environments. It has the following attributes:

  - `name`: The name of the environment (e.g., "development", "staging", "production")


pkgId: c6dff944972683e7eec111f1b9f5c5ecc248842e0aa83571eaa228b3ef6922e5
name: python-bluepyefe
arch: src
version: 2.3.35
epoch: 0
release: 1
summary: Blue Brain Python E-feature extraction
url: https://github.com/BlueBrain/BluePyEfe
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluepyefe-2.3.35-1.src.rpm
checksum_type: sha256
description:
  The Blue Brain Python E-feature extraction Library (BluePyEfe) aims at easing the process of reading experimental recordings and extracting batches of electrical features from them. To do so, it combines trace reading functions and features extraction functions from the eFel library. BluePyEfe outputs protocols and features files in a format that can then be used by BluePyOpt for electrical model building purposes.


pkgId: 3f783c85ccf9c34fc6a63e61f09574817805c2ad281ab3480d44d5bab5901dbd
name: python-bluepyefe
arch: src
version: 2.3.39
epoch: 0
release: 1
summary: Blue Brain Python E-feature extraction
url: https://github.com/BlueBrain/BluePyEfe
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluepyefe-2.3.39-1.src.rpm
checksum_type: sha256
rpm_license:
  BluePyEfe - Bluebrain Python E-feature extraction Library  BluePyEfe is licensed under the LGPL, unless noted otherwise, e.g., for external dependencies. See file LGPL.txt for the full license. Examples and test are BSD-licensed. External dependencies are either LGPL or BSD-licensed. See file AUTHORS.txt for further details.  Copyright (C) 2005-2024, Blue Brain Project/EPFL.  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.


pkgId: 93996e6312305f8424800d806e38eeaa8a753cbb89fc9ef8415b6b1ff809824c
name: python-bluepyemodel
arch: src
version: 1.0.24
epoch: 0
release: 1
summary: Blue Brain Python Electrical Modeling Pipeline
url: https://github.com/BlueBrain/BluePyEModel
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluepyemodel-1.0.24-1.src.rpm
checksum_type: sha256
description:
  +----------------+------------+
  | Latest Release | |pypi|     |
  +----------------+------------+
  | Documentation  | |docs|     |
  +----------------+------------+
  | License        | |license|  |
  +----------------+------------+
  | Build Status 	 | |tests|    |
  +----------------+------------+
  | Coverage       | |coverage| |
  +----------------+------------+
  | Citation       | |zenodo|   |
  +----------------+------------+

rpm_license:
  BluePyEModel is licensed under the Apache License, unless noted otherwise, e.g., for external dependencies. See file COPYING for the full license. The examples are under the CC-BY-NC-SA license, as specified by the LICENSE.txt file.   Copyright 2023-2024 Blue Brain Project / EPFL  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: 19f6fb43cd47de987925369103a1fd415cba0259ff309d2cde1aac78ee616030
name: python-bluepymm
arch: src
version: 0.9.11
epoch: 0
release: 1
summary: Model Management Python Library (bluepymm)
url: https://github.com/BlueBrain/BluePyMM
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluepymm-0.9.11-1.src.rpm
checksum_type: sha256
description:
  +----------------+------------+
  | Latest Release | |pypi|     |
  +----------------+------------+
  | Documentation  | |docs|     |
  +----------------+------------+
  | License        | |license|  |
  +----------------+------------+
  | Build Status 	 | |tests|    |
  +----------------+------------+
  | Coverage       | |coverage| |
  +----------------+------------+
  | Citation       | |zenodo|   |
  +----------------+------------+
  | Gitter         | |gitter|   |
  +----------------+------------+

rpm_license:
  BluePyMM - Bluebrain Python Optimisation Library  BluePyMM is licensed under the LGPL, unless noted otherwise, e.g., for external dependencies. See files COPYING and COPYING.lesser for the full license. Examples and test are BSD-licensed. External dependencies are either LGPL or BSD-licensed. See file ACKNOWLEDGEMENTS.txt and AUTHORS.txt for further details.  Copyright (C) 2005-2018, Blue Brain Project/EPFL.  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.


pkgId: 10a186ee07a87e0ffe1f06aef929376a8ecfb48ac1c40fbadfcb2e8d91735b67
name: python-bluepyopt
arch: src
version: 1.14.16
epoch: 0
release: 1
summary: Bluebrain Python Optimisation Library (bluepyopt)
url: https://github.com/BlueBrain/BluePyOpt
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluepyopt-1.14.16-1.src.rpm
checksum_type: sha256
description:
  The Blue Brain Python Optimisation Library (BluePyOpt) is an extensible framework for data-driven model parameter optimisation that wraps and standardises several existing open-source tools. It simplifies the task of creating and sharing these optimisations, and the associated techniques and knowledge. This is achieved by abstracting the optimisation and evaluation tasks into various reusable and flexible discrete elements according to established best-practices.


pkgId: e0e4a0a11b815a91d65010fa39dd29ced660ed8b6cf189a01ad954122512b2f6
name: python-bluepyopt
arch: src
version: 1.14.17
epoch: 0
release: 1
summary: Blue Brain Python Optimisation Library (bluepyopt)
url: https://github.com/BlueBrain/BluePyOpt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluepyopt-1.14.17-1.src.rpm
checksum_type: sha256
description:
  +----------------+------------+
  | Latest Release | |pypi|     |
  +----------------+------------+
  | Documentation  | |docs|     |
  +----------------+------------+
  | License        | |license|  |
  +----------------+------------+
  | Build Status 	 | |build|    |
  +----------------+------------+
  | Coverage       | |coverage| |
  +----------------+------------+
  | Gitter         | |gitter|   |
  +----------------+------------+
  | Zenodo         | |zenodo|   |
  +----------------+------------+

rpm_license:
  BluePyOpt - Bluebrain Python Optimisation Library  BluePyOpt is licensed under the LGPL, unless noted otherwise, e.g., for external dependencies. See files COPYING and COPYING.lesser for the full license. Examples and test are BSD-licensed. External dependencies are either LGPL or BSD-licensed. See file ACKNOWLEDGEMENTS.txt and AUTHORS.txt for further details.  Copyright (c) Blue Brain Project/EPFL 2016-2022.  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.


pkgId: 373df788984e09b04cd12baff30bc83578959473b89bd46b38ac8ded02e1fef8
name: python-blueqat
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Quantum Computer Library for Everyone
url: https://github.com/Blueqat/Blueqat
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueqat-2.0.4-1.src.rpm
checksum_type: sha256
description:
  ![Logo](https://raw.githubusercontent.com/Blueqat/Blueqat/master/blueqat_logo_blue.png)


  A Quantum Computing SDK


  [![Version](https://badge.fury.io/py/blueqat.svg)](https://badge.fury.io/py/blueqat)


  https://github.com/Blueqat/Blueqat-tutorials


  The back end has been changed to tensor network. The previous backend environment can still be used with .run(backend="numpy").


  ```
  git clone https://github.com/Blueqat/Blueqat
  cd Blueqat
  pip3 install -e .
  ```

  or

  ```
  pip3 install blueqat
  ```


  ```python
  from blueqat import Circuit
  import math


  c = Circuit()


  c = Circuit(50) #50qubits
  ```


  ```python

  Circuit().h[0].x[0].z[0]


  c = Circuit().h[0]
  c.x[0].z[0]
  ```


  ```python
  Circuit().z[1:3] # Zgate on 1,2
  Circuit().x[:3] # Xgate on (0, 1, 2)
  Circuit().h[:] # Hgate on all qubits
  Circuit().x[1, 2] # 1qubit gate with comma
  ```


  ```python
  Circuit().rz(math.pi / 4)[0]
  ```


  ```python
  from blueqat import Circuit
  Circuit(50).h[:].run()
  ```


  ```python
  Circuit(100).x[:].run(shots=100)

  ```


  ```python
  Circuit(4).h[:].run(amplitude="0101")
  ```


  ```python
  from blueqat.pauli import Z
  hamiltonian = 1*Z[0]+1*Z[1]
  Circuit(4).x[:].run(hamiltonian=hamiltonian)

  ```


  ```python
  Circuit().h[0].to_qasm()






  ```


  ```python
  from blueqat.pauli import *

  hamiltonian1 = (1.23 * Z[0] + 4.56 * X[1] * Z[2]) ** 2
  hamiltonian2 = (2.46 * Y[0] + 5.55 * Z[1] * X[2] * X[1]) ** 2
  hamiltonian = hamiltonian1 + hamiltonian2
  print(hamiltonian)


  ```


  ```python
  hamiltonian = hamiltonian.simplify()
  print(hamiltonian)


  ```


  ```python
  from blueqat.pauli import qubo_bit as q

  hamiltonian = -3*q(0)-3*q(1)-3*q(2)-3*q(3)-3*q(4)+2*q(0)*q(1)+2*q(0)*q(2)+2*q(0)*q(3)+2*q(0)*q(4)
  print(hamiltonian)


  ```


  ```python
  hamiltonian = [1.0*Z(0), 1.0*X[0]]
  a = [term.get_time_evolution() for term in hamiltonian]

  time_evolution = Circuit().h[0]
  for evo in a:
      evo(time_evolution, np.random.rand())

  print(time_evolution)


  ```


  ```python
  from blueqat import Circuit
  from blueqat.utils import qaoa
  from blueqat.pauli import qubo_bit as q
  from blueqat.pauli import X,Y,Z,I

  hamiltonian = q(0)-q(1)
  step = 1

  result = qaoa(hamiltonian, step)
  result.circuit.run(shots=100)


  ```



  ```python
  from blueqat import vqe
  from blueqat.pauli import *
  from blueqat.pauli import qubo_bit as q


  hamiltonian = Z[0]-3*Z[1]+2*Z[0]*Z[1]+3*Z[2]*Z[3]+Z[4]
  step = 8

  result = vqe.Vqe(vqe.QaoaAnsatz(hamiltonian, step)).run()
  result.circuit.run(backend='draw')
  ```

  ![draw](https://raw.githubusercontent.com/Blueqat/Blueqat/master/draw.png)


  ```python
  from bqcloud import register_api
  api = register_api("Your API Key")

  from bqcloud import load_api
  api = load_api()

  from blueqat import Circuit
  from bqcloud import Device

  task = api.execute(Circuit().h[0].cx[0, 1], Device.IonQDevice, 10)



  result = task.wait(timeout=10)

  if result:
      print(result.shots())
  else:
      print("timeout")
  ```


  https://blueqat.readthedocs.io/en/latest/


  [Contributors](https://github.com/Blueqat/Blueqat/graphs/contributors)


  Copyright 2022 The Blueqat Developers.


pkgId: 40d4dd22050c4abfd3de745f12b984beec2c83e4901a112a55f7b3821aaf3fff
name: python-bluequbit
arch: src
version: 0.9.2b1
epoch: 0
release: 1
summary: Python SDK to BlueQubit app
url: https://app.bluequbit.io
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluequbit-0.9.2b1-1.src.rpm
checksum_type: sha256
description:
  1. Register on https://app.bluequbit.io and copy the API token.

  2. Install Python SDK from PyPI:
  ```
      pip install bluequbit
  ```
  3. An example of how to run a Qiskit circuit using the SDK:

  ```
      import qiskit

      import bluequbit

      bq_client = bluequbit.init("<token>")

      qc_qiskit = qiskit.QuantumCircuit(2)
      qc_qiskit.h(0)
      qc_qiskit.x(1)

      job_result = bq_client.run(qc_qiskit, job_name="testing_1")

      state_vector = job_result.get_statevector()
      
  ```

  4. An example of how to run a Pennylane circuit:

  ```
      import pennylane as qml
      from pennylane import numpy as np

      dev = qml.device('bluequbit.cpu', wires=1, token="<token>")

      @qml.qnode(dev)
      def circuit(angle):
          qml.RY(angle, wires=0)
          return qml.probs(wires=0)


      probabilities = circuit(np.pi / 4)
      
  ```
  To use the Pennylane plugin, you must have `pennylane` version 0.37 or above installed.

  5. This SDK requires Python versions 3.9 or above. But we recommend using Python 3.10 or above.
  The package is tested extensively on Python 3.10.



  Please find detailed reference at https://app.bluequbit.io/sdk-docs.



  Please submit questions and issues to info@bluequbit.io.


pkgId: 7fc1b636ee35339999fc0f30c7d764b16c99c32183b56d19b509ce4bef16bbf9
name: python-bluerobotics-ping
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A python module for the Blue Robotics ping-protocol and products
url: https://www.bluerobotics.com
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluerobotics-ping-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Python library for the Blue Robotics ping-protocol, and devices that implement it.

  This library provides message apis to use the protocol, as well as device apis to use with the
  Blue Robotics Ping Echosounder and Ping360 scanning sonar.


pkgId: 4718e89e5ed6e80f64b42233baa7255cf4f61ccc7cfaac317d76c38d12052694
name: python-bluesky
arch: src
version: 1.13
epoch: 0
release: 1
summary: Experiment specification & orchestration.
url: https://pypi.org/project/bluesky/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluesky-1.13-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bluesky/bluesky/actions/workflows/ci.yml/badge.svg)](https://github.com/bluesky/bluesky/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/bluesky/bluesky/branch/main/graph/badge.svg)](https://codecov.io/gh/bluesky/bluesky)
  [![PyPI](https://img.shields.io/pypi/v/bluesky.svg)](https://pypi.org/project/bluesky)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  |    Source     |     <https://github.com/bluesky/bluesky>      |
  | :-----------: | :-------------------------------------------: |
  |     PyPI      |             `pip install bluesky`             |
  | Documentation |      <https://bluesky.github.io/bluesky>      |
  |   Releases    | <https://github.com/bluesky/bluesky/releases> |

  Bluesky is a library for experiment control and collection of scientific data
  and metadata. It emphasizes the following virtues:

  * **Live, Streaming Data:** Available for inline visualization and processing.
  * **Rich Metadata:** Captured and organized to facilitate reproducibility and
    searchability.
  * **Experiment Generality:** Seamlessly reuse a procedure on completely
    different hardware.
  * **Interruption Recovery:** Experiments are "rewindable," recovering cleanly
    from interruptions.
  * **Automated Suspend/Resume:** Experiments can be run unattended,
    automatically suspending and resuming if needed.
  * **Pluggable I/O:** Export data (live) into any desired format or database.
  * **Customizability:** Integrate custom experimental procedures and commands,
    and get the I/O and interruption features for free.
  * **Integration with Scientific Python:** Interface naturally with numpy and
    Python scientific stack.

  [**Bluesky Documentation**](http://blueskyproject.io/bluesky).

  The Bluesky Project enables experimental science at the lab-bench or facility scale. It is a collection of Python libraries that are co-developed but independently useful and may be adopted *a la carte*.

  [**Bluesky Project Documentation**](http://blueskyproject.io).

  <!-- README only content. Anything below this line won't be included in index.md -->

  See https://bluesky.github.io/bluesky for more detailed documentation.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2015, Brookhaven National Laboratory All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 17a2d2340b8bbf1c29b5f263b0f084cce945e10301fa4eb0997a0d9f87d71aec
name: python-bluesky-notify
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A cross-platform desktop notification system for Bluesky
url: https://github.com/jerdog/bluesky-notify
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluesky-notify-0.4.1-1.src.rpm
checksum_type: sha256
description:
  A cross-platform desktop notification system for Bluesky. Monitor and receive notifications from your favorite Bluesky accounts.

  [![Version](https://img.shields.io/badge/version-0.4.0-blue.svg)](https://github.com/jerdog/bluesky-notify)
  [![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
  [![Flask](https://img.shields.io/badge/Flask-3.1.0-blue)](https://pypi.org/project/Flask/)
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)



  - Monitor multiple Bluesky accounts for new posts
  - Desktop notifications support across platforms (macOS, Linux, Windows)
  - Daemon mode for continuous monitoring
  - Web interface for easy account management
  - Email notifications support (requires Mailgun configuration)
  - XDG-compliant configuration storage
  - SQLite database for reliable post tracking
  - Cross-platform compatibility
  - Consistent CLI interface with clear version and configuration information
  - Comprehensive logging system with rotation and separate error logs



  ```bash
  pip install bluesky-notify
  ```

  To verify the installation:
  ```bash
  bluesky-notify --version
  ```

  Example output:
  ```
  Bluesky Notify v0.4.0
  Config: /Users/username/.local/share/bluesky-notify

  A cross-platform desktop notification system for Bluesky. Monitor and receive notifications from your favorite Bluesky accounts.

  Usage: bluesky-notify [OPTIONS] COMMAND [ARGS]...

  Run 'bluesky-notify start --daemon' to install and run as a system service.

  Options:
    --version  Show version and exit
    --help     Show this message and exit.

  Commands:
    add       Add a Bluesky account to monitor.
    list      List all monitored Bluesky accounts and their notification...
    remove    Remove a Bluesky account from monitoring.
    settings  View or update application settings.
    start     Start the notification service.
    status    View the current status of the service.
    stop      Stop the notification service.
    toggle    Toggle monitoring status for a Bluesky account.
    update    Update notification preferences for a monitored account.
  ```



  The application uses the XDG Base Directory Specification for storing its data:

  - Configuration: `~/.config/bluesky-notify/`
  - Data: `~/.local/share/bluesky-notify/`
  - Cache: `~/.cache/bluesky-notify/`



  To enable email notifications, set the following environment variables:

  ```bash
  export MAILGUN_API_KEY='your-api-key'
  export MAILGUN_DOMAIN='your-domain'
  export MAILGUN_FROM_EMAIL='notifications@yourdomain.com'
  export MAILGUN_TO_EMAIL='your-email@example.com'
  ```





  To see all available commands and options:
  ```bash
  bluesky-notify --help
  ```



  ```bash
  bluesky-notify add username.bsky.social
  ```

  Note: The handle should be provided without the '@' symbol.

  Options:
  - `--desktop/--no-desktop`: Enable/disable desktop notifications (default: enabled)
  - `--email/--no-email`: Enable/disable email notifications (default: disabled)



  ```bash
  bluesky-notify list
  ```



  ```bash
  bluesky-notify remove username.bsky.social
  ```



  ```bash
  bluesky-notify toggle username.bsky.social
  ```



  ```bash
  bluesky-notify update username.bsky.social --desktop --no-email
  ```



  View the current status of the service:
  ```bash
  bluesky-notify status
  ```

  This will show:
  - Service status (running/not running) and mode (terminal/daemon)
  - Web interface status and URL
  - Data directory location
  - Current configuration



  Start the service:
  ```bash

  bluesky-notify start


  bluesky-notify start --daemon
  ```

  Stop the service:
  ```bash
  bluesky-notify stop
  ```
  The stop command will automatically detect whether the service is running in terminal or daemon mode and stop it accordingly.



  View current settings:
  ```bash
  bluesky-notify settings
  ```

  Update settings:
  ```bash

  bluesky-notify settings --interval 120


  bluesky-notify settings --log-level debug


  bluesky-notify settings --port 8080
  ```

  Available settings:
  - Check interval (in seconds)
  - Log level (DEBUG, INFO, WARNING, ERROR)
  - Web interface port



  The application uses a comprehensive logging system:

  - Log files are stored in `~/.local/share/bluesky-notify/logs/`
  - Two log files are maintained:
    - `bluesky-notify.log`: General application logs (INFO level and above)
    - `bluesky-notify.error.log`: Error-specific logs (ERROR level only)
  - Log rotation is enabled:
    - Maximum file size: 1MB
    - Keeps up to 5 backup files
    - Rotated files are named with numerical suffixes (e.g., bluesky-notify.log.1)

  Log levels can be configured using the settings command:
  ```bash
  bluesky-notify settings --log-level debug  # Set to DEBUG level
  bluesky-notify settings --log-level info   # Set to INFO level (default)
  ```



  - 0.4.0: Add web interface to daemon + terminal mode
  - 0.3.0: Add daemon mode, web interface, and improved CLI help text
  - 0.2.7: Fixed CLI output formatting and help text organization
  - 0.2.6: Enhanced CLI interface with consistent version and config display
  - 0.2.5: Improved help text formatting and command output
  - 0.2.4: Added version and config information to all commands
  - 0.2.3: Refined CLI presentation and version display
  - 0.2.0: Initial public release



  1. Clone the repository:
  ```bash
  git clone https://github.com/jerdog/bluesky-notify.git
  cd bluesky-notify
  ```

  2. Create a virtual environment:
  ```bash
  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  ```

  3. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```

  4. Build the package:
  ```bash
  python -m build
  ```

  5. Install the built package:
  ```bash
  pip install dist/bluesky_notify-0.4.0-py3-none-any.whl
  ```



  1. **Version Check**
     - Run `bluesky-notify --version` to verify the installed version
     - Make sure you have the latest version installed

  2. **No Notifications**
     - Check if desktop notifications are enabled in your system
     - Verify the notification service is running
     - Check logs in `~/.local/share/bluesky-notify/logs/`

  3. **API Errors**
     - Verify Bluesky handles are entered correctly (without '@' symbol)
     - Check your internet connection
     - Ensure the Bluesky API is accessible



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



  Contributions are welcome! Please feel free to submit a Pull Request.



  If you encounter any issues or have questions, please file an issue on the GitHub repository.


pkgId: 32d603719949b1b83868f5d0c6a4073f4ee0635cfd9f2485b0b7d15ccbc31e72
name: python-bluesky-stomp
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: STOMP integration for bluesky
url: https://pypi.org/project/bluesky-stomp/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluesky-stomp-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/DiamondLightSource/bluesky-stomp/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamondLightSource/bluesky-stomp/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/DiamondLightSource/bluesky-stomp/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/bluesky-stomp)
  [![PyPI](https://img.shields.io/pypi/v/bluesky-stomp.svg)](https://pypi.org/project/bluesky-stomp)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  STOMP integration for bluesky

  Source          | <https://github.com/DiamondLightSource/bluesky-stomp>
  :---:           | :---:
  PyPI            | `pip install bluesky-stomp`
  Releases        | <https://github.com/DiamondLightSource/bluesky-stomp/releases>



  The library comes with some helpers for interacting with a stomp broker:

  ```python
  from bluesky_stomp.messaging import MessageContext, StompClient
  from bluesky_stomp.models import Broker, MessageQueue, MessageTopic


  client = StompClient.for_broker(Broker(host="localhost", port=61613))

  try:
      
      client.connect()

      
      client.send(MessageQueue(name="my-queue"), {"foo": 1, "bar": 2})
      client.send(MessageTopic(name="my-topic"), {"foo": 1, "bar": 2})

      
      
      def on_message(message: str, context: MessageContext) -> None:
          print(message)

      client.subscribe(MessageTopic(name="my-other-topic"), on_message)

      
      
      reply_future = client.send_and_receive(
          MessageQueue(name="my-queue"), {"foo": 1, "bar": 2}
      )
      print(reply_future.result(timeout=5.0))
  finally:
      
      client.disconnect()
  ```

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


pkgId: 0b5f26231363cce7c9b68981352f1fd935a3977c4e8e14fed8b9182e217185ee
name: python-blueskysocial
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: API for BlueSky social network
url: https://github.com/dmoggles/blueskysocial
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueskysocial-1.4.0-1.src.rpm
checksum_type: sha256
description:
  blueskysocial is a Python library for managing social media posts and images. It provides a Client class for interacting with social media platforms, as well as classes for representing posts and images.



  To install blueskysocial, you can use pip:

  ```bash
  pip install blueskysocial
  ```





  ```python
  from blueskysocial import Client, Post, Image

  client = Client()
  client.authenticate(user_name, password)

  image = Image('path/to/image.jpg', alt_text='This is an image.')
  post = Post('Hello, world!, This is my first post.', images=[image])
  client.post(post)
  ```



  ```python
  from blueskysocial import Client, Post, Image

  client = Client(user_name, password)
  client.authenticate()

  image = Image('path/to/image.jpg', alt_text='This is an image.')
  post = Post('Hello, world!, This is my first post.', images=[image])
  second_post = Post('Another Post')
  client.post_thread([post,second_post])
  ```


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  blueskysocial is licensed under the MIT License. See [LICENSE](LICENSE) for more information.
  ```


pkgId: d1e5c370b27dc471484aa1c5b6f03695d5b10336102f20bd1c38ed1a1beee4bf
name: python-blueskysocial
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: API for BlueSky social network
url: https://github.com/dmoggles/blueskysocial
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueskysocial-1.6.2-1.src.rpm
checksum_type: sha256
description:
  blueskysocial is a Python library for managing social media posts and images. It provides a Client class for interacting with social media platforms, as well as classes for representing posts and images.



  To install blueskysocial, you can use pip:

  ```bash
  pip install blueskysocial
  ```





  ```python
  from blueskysocial import Client, Post, Image

  client = Client()
  client.authenticate(user_name, password)

  image = Image('path/to/image.jpg', alt_text='This is an image.')
  post = Post('Hello, world!, This is my first post.', with_attachments=[image])
  client.post(post)
  ```



  ```python
  from blueskysocial import Client, Post, Image

  client = Client()
  client.authenticate(user_name, password)

  image = Image('path/to/image.jpg', alt_text='This is an image.')
  post = Post('Hello, world!, This is my first post.', with_attachments=[image])
  second_post = Post('Another Post')
  client.post_thread([post,second_post])
  ```


  As of version 1.5.0, embedding video in your post is supported.  Currently video can only be embedded from a local file.  Please note, that when embedding a video in a post, it may take several minutes for Bluesky to process your video, during which a video frame with "Video Not Found" will appear in your post.

  The following video formats are supported
  - mp4
  - mpeg
  - webm
  - mov

  ```python
  from blueskysocial import Client, Post, Video
  client = Client()
  client.authenticate(user_name, password)

  video = Video('path/to/video.mov')
  post = Post('Video Post', with_attachments=video)
  client.post(post)
  ```


  Bluesky counts URL characters towards the 300 character limit.  The solution to this is to format your links.  `blueskysocial` supports markdown link formatting.  If you format your post text in the following fashion
  ```python
  from blueskysocial import Client, Post

  client = Client()
  client.authenticate(user_name, password)
  post = Post('Hello, world!, This is my first post.  But with a link.  [Click here](http://really.long.url.here)'),
  clinet.post(post)
  ```
  Your post text will be "Hello, world!, This is my first post. But with a link. Click here", with the words "Click here" being a link.  In this fashion, only the characters in "Click here" count towards the limit


  Webcards are the small preview images of a linked website that appear at the bottom of the posts and also serve as links.  You can embed a webcard with the following syntax
  ```python
  from blueskysocial import Client, Post, WebCard

  client = Client()
  client.authenticate(user_name, password)
  webcard = WebCard("http://url_to_link_to.com/article")
  post = Post('Check out this article!', with_attachments=webcard)
  clinet.post(post)
  ```

  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  blueskysocial is licensed under the MIT License. See [LICENSE](LICENSE) for more information.
  ```


pkgId: d9ee81065514e2ff3987040032f60b0f266931f57209dbc04100264fd7c0f784
name: python-bluetarget
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Deploy, monitor and explain your machine learning models
url: https://pypi.org/project/bluetarget/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluetarget-0.3.1-1.src.rpm
checksum_type: sha256
description:
  **Deploy, monitor and explain machine learning models.**

  ![Logo](https://deploy.bluetarget.ai/statics/bt.jpg)

  BlueTarget is a MLops platform which allows ML engineer and Data Science deploy, monitor and explain their machine learning models. We're able to deploy your model using different kind of strategies like A/B testing, Canary or Rolling update.

  Get started with the [BlueTarget](https://docs.deploy.bluetarget.ai).



  If you've ever tried to get a model out of a Jupyter notebook, BlueTargert is for you.

  BlueTarget allow your to deploy your ML model taking away the whole complexity of the cloud. However If you prefer to have the control of the infrastructure, BlueTarget can work with your preferred cloud:

  Here are some of the things BlueTarget does:

  - Turns your Python model into a microservice with a production-ready API endpoint, no need for Flask or Django.
  - Track your model's version and metadata
  - Understad the drift of your model
  - Track your inference
  - Deployment strategies like A/B testing, canary and rolling update



  BlueTarget requires Python >=3.7

  To install from [PyPi](https://pypi.org/project/bluetarget/), run:

  ```
  pip install bluetarget
  ```

  BlueTarget is actively developed, and we recommend using the latest version. To update your BlueTarget installation, run:

  ```
  pip install --upgrade bluetarget
  ```







  ```python
  !pip install --upgrade scikit-learn bluetarget pickle-mixin

  from sklearn import svm
  from sklearn import datasets

  import pickle


  iris = datasets.load_iris()
  X, y = iris.data, iris.target


  clf = svm.SVC(gamma='scale')
  clf.fit(X, y)

  pickle.dump(clf, open('model.pkl', 'wb'))

  ```



  ```python
  import os
  from typing import Dict, List

  class Model:
      def __init__(self) -> None:
          self._model = None

      def load(self):
          import pickle

          with open(f"{os.path.dirname(__file__)}/model.pkl", 'rb') as pickle_file:
              self._model = pickle.load(pickle_file)

      def predict(self, request: Dict) -> Dict[str, List]:
          response = {}
          inputs = request["inputs"]
          result = self._model.predict(inputs).tolist()
          response["predictions"] = result

          return response
  ```



  ```
  scikit-learn==1.0.2
  pickle-mixin==1.0.2
  ```



  ```python
  from bluetarget import BlueTarget

  bt = BlueTarget(api_key="YOUR_API_KEY")

  bt.deploy(
      model_name="YourFirstModel",
      model_class="Model",
      model_files=["model.py", "model.pkl"],
      requirements_file="requirements.txt"
  )

  inputs = [
      [6.9, 3.1, 5.1, 2.3],
      [5.8, 2.7, 5.1, 1.9],
      [6.8, 3.2, 5.9, 2.3],
      [6.7, 3.3, 5.7, 2.5],
      [6.7, 3.,  5.2, 2.3],
      [6.3, 2.5, 5.,  1.9],
      [6.5, 3.,  5.2, 2.],
      [6.2, 3.4, 5.4, 2.3],
      [5.9, 3.,  5.1, 1.8]
  ]

  bt.predict(inputs)















  ```


pkgId: 3be07748cea0db426541e0859953ae98e7cee8590892d3020a9819030be4cfe4
name: python-bluetooth-adapters
arch: src
version: 0.20.0
epoch: 0
release: 1
summary: Tools to enumerate and find Bluetooth Adapters
url: https://github.com/bluetooth-devices/bluetooth-adapters
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluetooth-adapters-0.20.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bluetooth-devices/bluetooth-adapters/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/bluetooth-devices/bluetooth-adapters/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://bluetooth-adapters.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/bluetooth-adapters.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/bluetooth-devices/bluetooth-adapters">
      <img src="https://img.shields.io/codecov/c/github/bluetooth-devices/bluetooth-adapters.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/bluetooth-adapters/">
      <img src="https://img.shields.io/pypi/v/bluetooth-adapters.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/bluetooth-adapters.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/bluetooth-adapters.svg?style=flat-square" alt="License">
  </p>

  Tools to enumerate and find Bluetooth Adapters



  Install this via pip (or your favourite package manager):

  `pip install bluetooth-adapters`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: ba5e63aca92dfd0d48ac447626c0237395c0fccab311351fd54f29b6d753b05a
name: python-bluetooth-auto-recovery
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Recover bluetooth adapters that are in an stuck state
url: https://github.com/bluetooth-devices/bluetooth-auto-recovery
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluetooth-auto-recovery-1.4.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bluetooth-devices/bluetooth-auto-recovery/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/bluetooth-devices/bluetooth-auto-recovery/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://bluetooth-auto-recovery.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/bluetooth-auto-recovery.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/bluetooth-devices/bluetooth-auto-recovery">
      <img src="https://img.shields.io/codecov/c/github/bluetooth-devices/bluetooth-auto-recovery.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/bluetooth-auto-recovery/">
      <img src="https://img.shields.io/pypi/v/bluetooth-auto-recovery.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/bluetooth-auto-recovery.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/bluetooth-auto-recovery.svg?style=flat-square" alt="License">
  </p>

  Recover bluetooth adapters that are in an stuck state



  The code in this repo originates from https://github.com/custom-components/ble_monitor/blob/master/custom_components/ble_monitor/bt_helpers.py



  Install this via pip (or your favourite package manager):

  `pip install bluetooth-auto-recovery`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: 15f132cf446accac3c85df5d2a5d72e12d7197fd6a7314614eae047e34cf25c6
name: python-bluetooth-data-tools
arch: src
version: 1.20.0
epoch: 0
release: 1
summary: Tools for converting bluetooth data and packets
url: https://github.com/bdraco/bluetooth-data-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluetooth-data-tools-1.20.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bdraco/bluetooth-data-tools/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/bdraco/bluetooth-data-tools/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://bluetooth-data-tools.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/bluetooth-data-tools.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/bdraco/bluetooth-data-tools">
      <img src="https://img.shields.io/codecov/c/github/bdraco/bluetooth-data-tools.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/bluetooth-data-tools/">
      <img src="https://img.shields.io/pypi/v/bluetooth-data-tools.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/bluetooth-data-tools.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/bluetooth-data-tools.svg?style=flat-square" alt="License">
  </p>

  Tools for converting bluetooth data and packets



  Install this via pip (or your favourite package manager):

  `pip install bluetooth-data-tools`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: 3773b9d82c29b7023ee3244dbfb64010f3f59bd8a045ad60733164252e97e027
name: python-bluetooth-sensor-state-data
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: Models for storing and converting Bluetooth Sensor State Data
url: https://github.com/bluetooth-devices/bluetooth-sensor-state-data
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluetooth-sensor-state-data-1.7.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bluetooth-devices/bluetooth-sensor-state-data/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/bluetooth-devices/bluetooth-sensor-state-data/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://bluetooth-sensor-state-data.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/bluetooth-sensor-state-data.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/bluetooth-devices/bluetooth-sensor-state-data">
      <img src="https://img.shields.io/codecov/c/github/bluetooth-devices/bluetooth-sensor-state-data.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/bluetooth-sensor-state-data/">
      <img src="https://img.shields.io/pypi/v/bluetooth-sensor-state-data.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/bluetooth-sensor-state-data.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/bluetooth-sensor-state-data.svg?style=flat-square" alt="License">
  </p>

  Models for storing and converting Bluetooth Sensor State Data



  Install this via pip (or your favourite package manager):

  `pip install bluetooth-sensor-state-data`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: 9acfc0ef23f995bc040d4706764281db3649c234b29f2d399674e0080e5b2447
name: python-bluetree-shopify-book
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: A Python package for managing books in Shopify
url: https://github.com/sikegame/bluetree-shopify-book
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluetree-shopify-book-0.2.3-1.src.rpm
checksum_type: sha256
description:
  The Shopify Book Service is a Python library for managing books in a Shopify store. It provides a simple interface for performing CRUD (Create, Read, Update, Delete) operations on books, as well as for setting up and managing metafields for books.



  To install the Shopify Book Service, run the following command:

  `pip install bluetree-shopify-book`



  To use the Shopify Book Service, you first need to create an instance of the ShopifyBookService class with your shop's URL and API access token:

  ```
  from bluetree_shopify_book import ShopifyBookService

  shop_url = "https://yourshopdomain.myshopify.com"
  admin_api_access_token = "YOUR_ACCESS_TOKEN"

  book_service = ShopifyBookService(shop_url, admin_api_access_token)
  ```

  Note that the ShopifyBookService class uses a context manager, so you can use it in a with statement to automatically activate and clear the Shopify session:

  ```
  with ShopifyBookService(shop_url, admin_api_access_token) as book_service:
      
  ```



  To get a book by ID, use the get_book_by_id() method:

  ```
  book = book_service.get_book_by_id(8148173881647)
  ```

  To get a book by ISBN, use the get_book_by_isbn() method:

  ```
  book = book_service.get_book_by_isbn("9780141439846")
  ```



  To create a book, use the create_book() method:

  ```
  from src.schema import CreateBookInput

  book_input = CreateBookInput(
      title="Pride and Prejudice",
      author="Jane Austen",
      description="A classic novel about love and social status.",
      price="12.99",
      sku="9780141439846",
      published_date="1813-01-28",
  )

  book = book_service.create_book(book_input)
  ```



  ```
  from src.schema import CreateBookInput

  book_inputs = [
      CreateBookInput(
          title="Pride and Prejudice",
          author="Jane Austen",
          description="A classic novel about love and social status.",
          price="12.99",
          sku="9780141439846",
          published_date="1813-01-28",
      ),
      CreateBookInput(
          title="To Kill a Mockingbird",
          author="Harper Lee",
          description="A powerful novel about race and justice in the American South.",
          price="14.99",
          sku="9780061120084",
          published_date="1960-07-11",
      ),
  ]

  books = book_service.create_books(book_inputs)
  ```



  To update a book's price, use the update_book_price() method:

  ```
  from decimal import Decimal

  book_variant_id = 1234567890
  new_price = Decimal("14.99")

  book = book_service.update_book_price(book_variant_id, new_price)
  ```



  To delete a book, use the delete_book() method:

  ```
  book_id = 1234567890

  book_service.delete_book(book_id)
  ```



  To set up default metafield definitions for books, use the setup_default_metafield_definitions() method:

  ```
  book_service.setup_default_metafield_definitions()
  ```



  To get all metafield definitions for books, use the _get_metafield_definitions() method:

  ```
  metafield_definitions = book_service
  ```
  The MIT License (MIT)

  Copyright, 2023 Shinsuke Ikegame.

  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: 62284bc4cdb0509920ef82afe5ee6ad80f2b12712a3251ccd77491807a4b7b72
name: python-blueutils
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: This is a crypto operation tool
url: https://github.com/ox-blueblue/blueutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueutils-0.0.2-1.src.rpm
checksum_type: sha256
description:
  这是一个python 的 crypto 工具集


  ```
  $ pip install blueutils
  ```


  比特浏览器官方虽然提供了api文档，但是没法直接拿来用，所以我对官方api文档进行封装了下，使用起来更简单了，使用方法如下：


  ```
  from blueutils.bitbrowser_api import BitBrowser

  b = BitBrowser(id="你的浏览器id")
  b.open()
  context = b.get_browser_context()
  print(context)
  b.close()
  ```


pkgId: f103686c3826a31f122751ec20aec81be25c4404260f6e8f20889ae5ee1047f4
name: python-blueutils
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: This is a crypto operation tool
url: https://github.com/ox-blueblue/blueutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueutils-0.0.3-1.src.rpm
checksum_type: sha256
description:
  这是一个python 的 crypto 工具集


  ```
  $ pip install blueutils
  ```


  比特浏览器官方虽然提供了api文档，但是没法直接拿来用，所以我对官方api文档进行封装了下，使用起来更简单了，使用方法如下：


  ```python
  from blueutils.bitbrowser_api import BitBrowser

  b = BitBrowser(id="你的浏览器id")
  b.open()
  context = b.get_browser_context()
  print(context)
  b.close()
  ```


pkgId: a223ba7dd1c8454fff9834802f983af1f7228cfe9a09794a50fa57b9948973af
name: python-blueye-protocol
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: Python protocol definition for the Blueye drones
url: https://www.blueyerobotics.com
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blueye-protocol-2.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/BluEye-Robotics/blueye.protocol/workflows/Tests/badge.svg)](https://github.com/BluEye-Robotics/blueye.protocol/actions)

  **Deprecation notice**

  Blunux 3.0 introduces a new protocol based on [Protobuf](https://developers.google.com/protocol-buffers/) messages passed over a [ZeroMQ](https://zeromq.org/) layer. Starting with Blunux 3.1 the old TCP/UDP based protocol will no longer be supported/compatible.



  This repository contains a python library that defines how to communicate with the underwater drones made by [Blueye Robotics](https://blueyerobotics.com).

  The protocol itself is defined in another repository, [ProtocolDefinitions](https://github.com/BluEye-Robotics/ProtocolDefinitions), as is stored as a submodule in this repository. The python code in this repository is (mostly) generated from those definitions.

  The `blueye.protocol` package's primary use case is in the [`blueye.sdk`](https://github.com/BluEye-Robotics/blueye.sdk). The SDK implements the necessary "plumbing" to utilize the protocol defined here in `blueye.protocol`, and will make interacting with the Blueye drones much easier. If you wish to interact with the drones in your own project we recommend using the `blueye.sdk` package, not `blueye.protocol` directly.

  This package requires Python 3.8 or newer.


  ```shell
  pip install blueye.protocol
  ```




  We use Poetry for dependency/package management, see the [Poetry docs](https://python-poetry.org/docs/) for installation instructions.



  **Important**: This repository includes generated code. If the protocol definitions are changed the generated files need to be updated and committed. The generators are run with:

  `invoke generate-udp`

  `invoke generate-tcp`

  `invoke generate-proto`



  The tests are located in the `tests` folder, and written using the `pytest` library.

  The tests can be run using invoke (to ensure that the protocol files are updated)

  ``` shell
  invoke test
  ```
  or directly using pytest (if you don't want to generate the definitions)

  ``` shell
  pytest
  ```


  Since bitbake doesn't have support for pyproject.toml files yet, we need to include a
  `setup.py` file to specify the dependencies needed. There's an invoke task for
  generating the file that can be run with
  ``` shell
  invoke generate-setup-py
  ```

  If you are running MacOS, you need to install gnu-tar
  ``` shell
  brew install gnu-tar
  ```

  and then run the follwing line before the invoke command:
  ``` shell
  PATH="/opt/homebrew/opt/gnu-tar/libexec/gnubin:$PATH"
  ```

  **Be sure to run this script and commit the `setup.py` file when the dependencies have
  changed.**


pkgId: e6ad6d4a787d05b14a76c30f1fb74e0360757952b115deb3854d43f2ad6f37bd
name: python-bluish
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A CI/CD tool
url: https://github.com/luismedel/bluish
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluish-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![justforfunnoreally.dev badge](https://img.shields.io/badge/justforfunnoreally-dev-9ff)](https://justforfunnoreally.dev)



  A CI/CD automation tool that runs everywhere and has `make` ergonomics.



  - YAML-based declarative approach (not that I love YAML, but...)
  - Githubactions-esque philosphy, but way simpler. In fact, Bluish is nearer to Make than to GA.
  - Runs _everywhere_, not tied to any vendor. Fire Bluish workflows from Github Actions, from a Gitlab workflow or from a cron-invoked shell script.
  - Simple as hell. I only add new actions whenever I need them.



  Please, refer to the [project wiki](https://github.com/luismedel/bluish/wiki).



  If you know other CI/CD tools, the following yaml will look more than familiar to you and you don't need any further explanation.

  ```yaml
  var:
    PYTHON_VERSION: "3.11"
    PYTEST_RUNNERS: 2

  jobs:
    lint:
      name: Runs ruff and mypy
      steps:
        - run: |
            ruff version
            ruff check src/ test/
            echo ""
            mypy --version
            mypy --ignore-missing-imports --python-version=${{ var.PYTHON_VERSION }} src/ test/

    fix:
      name: Reformats the code using ruff
      depends_on:
        - lint
      steps:
        - run: |
            echo ""
            ruff version
            ruff check --select I --fix src/ test/
            ruff format src/

    test:
      name: Run tests
      steps:
        - run: |
            pytest -n ${{ var.PYTEST_RUNNERS }}
  ```


pkgId: bc2fa6461be021a9aebb8d124614b39ef06c94b12f702916916e9a42f891d75f
name: python-bluish
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: A CI/CD tool
url: https://github.com/luismedel/bluish
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluish-0.7.2-1.src.rpm
checksum_type: sha256
description:
  [![justforfunnoreally.dev badge](https://img.shields.io/badge/justforfunnoreally-dev-9ff)](https://justforfunnoreally.dev)



  > ##  Note to readers: This documentation is still in its early stages and may be (in fact, it is) incomplete.

  Bluish automates software development and deployment tasks, similar to GitHub Actions, but for local execution or within Docker environments. This allows you to define, organize, and execute complex workflows in your own environment without relying on external services.



  Bluish offers the following features to streamline your development workflows:

  - **Make-like Ergonomics**: Bluish provides a command-line experience similar to `make`, thanks to its `blu` command. This allows you to quickly execute common tasks with commands like `blu build`, providing a familiar and efficient workflow for developers used to `make`.

  - **Local Automation**: Execute complex tasks without the need for cloud services. Everything happens in your local environment, ensuring greater control over the process.

  - **Container Integration**: Bluish can integrate with Docker, making it easy to run workflows inside containers, ensuring a controlled and replicable environment.

  - **Easy to Configure**: Uses YAML files to define workflows, similar to GitHub Actions. This allows you to define steps in a clear and organized manner.

  - **Extensible**: Thanks to its modular approach, you can easily customize and extend Bluish to suit your specific needs.

  - **CI/CD Integration**: Bluish can be integrated with GitHub Actions, GitLab CI/CD, and other CI/CD runners. This allows you to have unified workflows that can be executed both locally and in different CI/CD environments, without needing to adapt to the specific characteristics of each platform. The same workflow you run locally can also be executed in other CI/CD systems.



  To install Bluish, you need to have Python (version 3.8 or higher) and Docker (version 20.10 or higher) installed on your machine.

  ```bash
  pip install bluish
  ```



  _Please, refer to the project [wiki](https://github.com/luismedel/bluish/wiki) for a more in depth documentation._

  Bluish uses a YAML configuration file (`bluish.yml`) to define workflows. Each workflow consists of multiple steps, which are executed in sequence. Below is a basic example of a configuration file:

  ```yaml
  name: My Local Workflow

  steps:
    - name: Clone repository
      uses: git/checkout
      with:
        repository: https://github.com/myuser/myproject.git

    - name: Build Docker image
      run: docker build -t myproject .

    - name: Run tests
      run: docker run --rm myproject pytest

    - name: Cleanup
      run: docker rmi myproject
  ```

  Each workflow is defined by a series of steps, each with a name and a command that will be executed in your local environment or in a Docker container.

  To run a workflow, simply use the command:

  ```bash
  blu <workflow>
  ```

  This command will look for the `bluish.yml` file in the current directory or in the `.bluish/` directory and execute the defined steps. If both files exist, `bluish.yml` in the current directory will take precedence.



  Here are some common examples of how Bluish can facilitate your daily workflow:

  - **Local Continuous Integration**: Automate the process of building and testing your project without relying on a cloud CI platform.
  - **Reproducible Environments with Docker**: Run and test your code in containers to ensure it behaves the same way regardless of where it is deployed.
  - **Repetitive Scripts**: Automate repetitive development tasks, such as running tests, cleaning up artifacts, or generating builds in a simple way.



  Bluish offers a similar experience to GitHub Actions, but with the advantage of being able to run locally or in your own containers. Below is a summary of the key differences:

  | Feature               | GitHub Actions                | Bluish                                         |
  | --------------------- | ----------------------------- | ---------------------------------------------- |
  | Execution Environment | Cloud                         | Local / Docker Containers                      |
  | Privacy               | Data hosted on GitHub servers | Fully local, no data exposure                  |
  | Flexibility           | Tied to GitHub's CI/CD model  | Agnostic, adaptable to different CI/CD systems |
  | Internet Requirement  | Yes                           | No                                             |

  This makes Bluish ideal for developers who need:

  - **Privacy**: Run workflows without exposing data to third-party platforms.
  - **Flexibility and Control**: Define and modify environments and dependencies without limitations imposed by an external service.
  - **Offline Development**: Use automated workflows without an internet connection.
  - **Unified CI/CD Workflows**: Execute the same workflows both locally and in CI/CD environments like GitHub Actions, GitLab CI/CD, and others, making it easier to maintain consistency across different stages of development and deployment.



  While the superb [nektos/act](https://github.com/nektos/act) allows you to run GitHub Actions locally, it is tied to the GitHub Actions specification, which can limit flexibility. For example, `nektos/act` strictly adheres to the GitHub Actions syntax and conventions, which means that workflows must follow GitHub's specific rules and may require adaptation if used elsewhere.

  Bluish, on the other hand, is more agnostic and allows you to define and execute workflows without being restricted to the GitHub Actions structure. This makes Bluish a more versatile choice if you are looking to create workflows that can be used across multiple CI/CD systems or if you prefer not to be bound by a specific CI/CD provider's conventions.



  Contributions are welcome! If you want to improve Bluish, feel free to open an issue or send a pull request. Check the [contribution guidelines](https://github.com/luismedel/bluish/blob/main/CONTRIBUTING.md) in the repository for more details.



  This project is licensed under the MIT License. See the `LICENSE` file for more information.



  For any questions or suggestions, feel free to open an issue in the repository or contact me directly through my GitHub profile: [luismedel](https://github.com/luismedel).


pkgId: 96b63082351883aa4433642db34400f7cce416b80881324f56d7e9e62859a1c2
name: python-bluish
arch: src
version: 0.7.6
epoch: 0
release: 1
summary: A CI/CD tool
url: https://github.com/luismedel/bluish
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluish-0.7.6-1.src.rpm
checksum_type: sha256
description:
  [![justforfunnoreally.dev badge](https://img.shields.io/badge/justforfunnoreally-dev-9ff)](https://justforfunnoreally.dev)


  Bluish automates software development and deployment tasks, similar to GitHub Actions, but for local execution or within Docker. It allows you to define, organize, and execute workflows in your own environment without relying on external services.



  - **Command-Line Interface**: Bluish offers a `make`-like experience via the `blu` command for easy task execution (e.g., `blu build`).
  - **Local and Remote Automation**: Execute tasks locally, without needing cloud services, or remotely via SSH.
  - **Docker Integration**: Run workflows in Docker containers for a controlled environment.
  - **Simple Configuration**: Define workflows in YAML files, following a familiar structure for defining steps.
  - **CI/CD Integration**: Integrate with GitHub Actions, GitLab CI/CD, and other CI/CD tools for unified local and remote workflows.



  ```bash
  pip install bluish
  ```



  Refer to the project [wiki](https://github.com/luismedel/bluish/wiki) for more detailed documentation. Please note that the documentation is still in progress and may be incomplete or not fully reliable.

  Define workflows in a YAML file (`bluish.yml`). Each workflow contains steps executed in sequence. Example:

  ```yaml
  name: My Local Workflow

  steps:
    - name: Clone repository
      uses: git/checkout
      with:
        repository: https://github.com/myuser/myproject.git

    - name: Build Docker image
      run: docker build -t myproject .

    - name: Run tests
      run: docker run --rm myproject pytest

    - name: Cleanup
      run: docker rmi myproject
  ```

  To run a workflow:

  ```bash
  blu <workflow>
  ```

  The command looks for `bluish.yml` in the current or `.bluish/` directory.



  - **Local CI**: Build and test your project without a cloud CI platform.
  - **Reproducible Environments**: Run code in Docker containers for consistency.
  - **Task Automation**: Automate repetitive development tasks.



  | Feature               | GitHub Actions                | Bluish                                         |
  | --------------------- | ----------------------------- | ---------------------------------------------- |
  | Execution Environment | Cloud                         | Local / Remote / Docker Containers             |
  | Privacy               | Data hosted on GitHub servers | No data exposure, or exposure that is tightly controlled                               |
  | Flexibility           | Tied to GitHub's CI/CD model  | Agnostic, adaptable to different CI/CD systems |
  | Internet Requirement  | Yes                           | No                                             |

  Bluish is ideal for:

  - **Privacy**: No data exposed to third-party platforms.
  - **Control**: Define and modify environments without external limitations.
  - **Offline Development**: Use workflows without internet.
  - **Unified Workflows**: Consistent local and CI/CD workflows.



  [nektos/act](https://github.com/nektos/act) runs GitHub Actions locally but is tied to GitHub's syntax. Bluish offers more flexibility and is not restricted by GitHub-specific rules, making it more versatile across different CI/CD systems.



  Contributions are welcome! Open an issue or send a pull request. See the [contribution guidelines](https://github.com/luismedel/bluish/blob/main/CONTRIBUTING.md) for more details.



  Licensed under the MIT License. See the `LICENSE` file for details.



  For questions or suggestions, open an issue in the repository or contact me on GitHub: [luismedel](https://github.com/luismedel).


pkgId: 7f6d3e56dd83e33dfe07da36b5806f05624f5bf55e3d21ad30216dab1cf06b8d
name: python-bluprint
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/igor-sb/bluprint
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bluprint-0.4.5-1.src.rpm
checksum_type: sha256
description:
  |CI_badge| |codecov_badge| |license_badge| |version_badge|
  **Bluprint** is a command line utility for creating data science project
  templates, allowing R and Jupyter notebooks seamless access to configuration,
  data and shared code in this type of structure::
      my_project
      ├── conf
      │   └── data.yaml              # YAML config with data paths
      ├── data                       # Store smaller data
      │   ├── emailed
      │   │   └── messy.xlsx
      │   └── user_processed.csv
      ├── notebooks                  # Notebooks
      │   └── process.ipynb
      └── my_project                 # Local Python package used by my_project
          └── shared_code.py
  Configuration *conf/data.yaml* contains either absolute paths or paths relative
  to the *my_project/data/*:
      emailed:
          messy: 'emailed/messy.xlsx'
      user:
          processed: 'user_processed.csv'
  Notebooks can then easily import *myproject.shared_code* and file paths:
      from bluprint.config import load_data_yaml
      data = load_data_yaml()  # By default loads conf/data.yaml
      
      import pandas as pd
      messy_df = pd.read_xlsx(data.emailed.messy)
      extras_df = pd.read_xlsx(data.remote.extras)
      
      
      from my_project.shared_code import transform_data
      transformed_df = transform_data(messy_df, extras_df)
      
      transformed_df.to_csv(data.user.processed)
  For a working demonstration of a shareable project see
  https://github.com/igor-sb/bluprint-demo/.


pkgId: efb853d282f6e005248fc24088d0de5d66dd8ecb8225e1152b855b59ae41634c
name: python-blur-detector
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://github.com/Utkarsh-Deshmukh/Spatially-Varying-Blur-Detection-python
rpm_license: BSD 2-Clause "Simplified" License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blur-detector-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  Uses discrete cosine transform coefficients at multiple scales and uses max pooling on the high frequency coefficients to get the sharp areas in an image.

description:
  python implementation of the paper "Spatially-Varying Blur Detection Based on Multiscale Fused and Sorted Transform Coefficients of Gradient Magnitudes" - cvpr 2017


  Uses discrete cosine transform coefficients at multiple scales and uses max pooling on the high frequency coefficients to get the sharp areas in an image.


  This library performs Spatially Varying Blur Detection which is can be used in many applications such as Depth of field estimation, Depth from Focus estimation, Blur Magnification, Deblurring etc.



  To install, run:
  `pip install blur-detector`


  ```
  import blur_detector
  import cv2
  if __name__ == '__main__':
  	img = cv2.imread('image_name', 0)
  	blur_map = blur_detector.detectBlur(img, downsampling_factor=4, num_scales=4, scale_start=2, num_iterations_RF_filter=3, show_progress=True)

  	cv2.imshow('ori_img', img)
  	cv2.imshow('blur_map', blur_map)
  	cv2.waitKey(0)
  ```
  As easy as that!!


pkgId: 79733ab4b965a370b8bdac09c42c5846784fb00fa5e667a97592339cb37488c7
name: python-blurb
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Command-line tool to manage CPython Misc/NEWS.d entries.
url: https://github.com/python/blurb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blurb-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/blurb.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/blurb)
  [![GitHub Actions](https://github.com/python/blurb/actions/workflows/test.yml/badge.svg)](https://github.com/python/blurb/actions)
  [![Codecov](https://codecov.io/gh/python/blurb/branch/main/graph/badge.svg)](https://codecov.io/gh/python/blurb)
  [![Python discussions](https://img.shields.io/badge/Discourse-join_chat-brightgreen.svg)](https://discuss.python.org/)



  **blurb** is a tool designed to rid CPython core development
  of the scourge of `Misc/NEWS` conflicts.

  The core concept: split `Misc/NEWS` into many
  separate files that, when concatenated back together
  in sorted order, reconstitute the original `Misc/NEWS` file.
  After that, `Misc/NEWS` could be deleted from the CPython
  repo and thereafter rendered on demand (e.g. when building
  a release).  When committing a change to CPython, the commit
  process will write out a new file that sorts into the correct place,
  using a filename unlikely to have a merge conflict.

  **blurb** is a single command with a number of subcommands.
  It's designed  to be run inside a valid CPython (Git) repo,
  and automatically uses the correct file paths.

  You can install **blurb** from PyPI using `pip`.  Alternatively,
  simply add `blurb` to a directory on your path.




  **blurb** uses a new directory tree called `Misc/NEWS.d`.
  Everything it does is in there, except for possibly
  modifying `Misc/NEWS`.

  Under `Misc/NEWS.d` you'll find the following:

  * A single file for all news entries per previous revision,
    named for the exact version number, with the extension `.rst`.
    Example: `Misc/NEWS.d/3.6.0b2.rst`.

  * The `next` directory, which contains subdirectories representing
    the various `Misc/NEWS` categories.  Inside these subdirectories
    are more `.rst` files with long, uninteresting, computer-generated
    names.  Example:
    `Misc/NEWS.d/next/Library/2017-05-04-12-24-06.gh-issue-25458.Yl4gI2.rst`




  Like many modern utilities, **blurb** has only one executable
  (called `blurb`), but provides a diverse set of functionality
  through subcommands.  The subcommand is the first argument specified
  on the command-line.

  If you're a CPython contributor, you probably don't need to use
  anything except `blurb add` — and you don't even need to specify
  the `add` part.
  (If no subcommand is specified, **blurb** assumes you meant `blurb add`.)
  The other commands are only expected to be useful for CPython release
  managers.





  **blurb** is self-documenting through the `blurb help` subcommand.
  Run without any further arguments, it prints a list of all subcommands,
  with a one-line summary of the functionality of each.  Run with a
  third argument, it prints help on that subcommand (e.g. `blurb help release`).




  `blurb add` adds a new `Misc/NEWS` entry for you.
  It opens a text editor on a template; you edit the
  file, save, and exit.  **blurb** then stores the file
  in the correct place, and stages it in Git for you.

  The template for the `blurb add` message looks like this:

      
      
      
      .. gh-issue:

      
      
      
      
      
      
      
      
      
      
      
      
      
      
      

      
      
      

  Here's how you interact with the file:

  * Add the GitHub issue number for this commit to the
    end of the `.. gh-issue:` line.

  * Uncomment the line with the relevant `Misc/NEWS` section for this entry.
    For example, if this should go in the `Library` section, uncomment
    the line reading `#.. section: Library`.  To uncomment, just delete
    the `#` at the front of the line.

  * Finally, go to the end of the file, and enter your `NEWS` entry.
    This should be a single paragraph of English text using
    simple reST markup.

  When `blurb add` gets a valid entry, it writes it to a file
  with the following format:

      Misc/NEWS.d/next/<section>/<datetime>.gh-issue-<issue_number>.<nonce>.rst

  For example, a file added by `blurb add` might look like this::

      Misc/NEWS.d/next/Library/2017-05-04-12-24-06.gh-issue-25458.Yl4gI2.rst

  `<section>` is the section provided in the commit message.

  `<datetime>` is the current UTC time, formatted as
  `YYYY-MM-DD-hh-mm-ss`.

  `<nonce>` is a hopefully-unique string of characters meant to
  prevent filename collisions.  **blurb** creates this by computing
  the MD5 hash of the text, converting it to base64 (using the
  "urlsafe" alphabet), and taking the first 6 characters of that.


  This filename ensures several things:

  * All entries in `Misc/NEWS` will be sorted by time.

  * It is unthinkably unlikely that there'll be a conflict
    between the filenames generated for two developers committing,
    even if they commit in at the exact same second.


  Finally, `blurb add` stages the file in git for you.




  `blurb merge` recombines all the files in the
  `Misc/NEWS.d` tree back into a single `NEWS` file.

  `blurb merge` accepts only a single command-line argument:
  the file to write to.  By default, it writes to
  `Misc/NEWS` (relative to the root of your CPython checkout).

  Splitting and recombining the existing `Misc/NEWS` file
  doesn't recreate the previous `Misc/NEWS` exactly.  This
  is because `Misc/NEWS` never used a consistent ordering
  for the "sections" inside each release, whereas `blurb merge`
  has a hard-coded preferred ordering for the sections.  Also,
  **blurb** aggressively reflows paragraphs to < 78 columns,
  wheras the original hand-edited file occasionally had lines >
  80 columns.  Finally, **blurb** strictly uses `gh-issue-<n>:` to
  specify issue numbers at the beginnings of entries, wheras
  the legacy approach to `Misc/NEWS` required using `Issue #<n>:`.




  `blurb release` is used by the release manager as part of
  the CPython release process.  It takes exactly one argument,
  the name of the version being released.

  Here's what it does under the hood:

  * Combines all recently-added NEWS entries from
    the `Misc/NEWS.d/next` directory into `Misc/NEWS.d/<version>.rst`.
  * Runs `blurb merge` to produce an updated `Misc/NEWS` file.

  One hidden feature: if the version specified is `.`, `blurb release`
  uses the name of the directory CPython is checked out to.
  (When making a release I generally name the directory after the
  version I'm releasing, and using this shortcut saves me some typing.)





  You may have noticed that `blurb add` adds news entries to
  a directory called `next`, and `blurb release` combines those
  news entries into a single file named with the version.  Why
  is that?

  First, it makes naming the next version a late-binding decision.
  If we are currently working on 3.6.5rc1, but there's a zero-day
  exploit and we need to release an emergency 3.6.5 final, we don't
  have to fix up a bunch of metadata.

  Second, it means that if you cherry-pick a commit forward or
  backwards, you automatically pick up the `NEWS` entry too.  You
  don't need to touch anything up — the system will already do
  the right thing.  If `NEWS` entries were already written to the
  final version directory, you'd have to move those around as
  part of the cherry-picking process.



  **blurb** is Copyright 2015-2018 by Larry Hastings.
  Licensed to the PSF under a contributor agreement.



  See [CHANGELOG.md](CHANGELOG.md).


pkgId: 46b17a2abcd8cb060ee3987e0b0ac024456f2d3684c5757d26f887da3976dc11
name: python-blurhash-avif
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A library to generate BlurHash and PNG data URLs for AVIF images
url: https://github.com/ZuidVolt/blurhash-avif
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blurhash-avif-0.7.1-1.src.rpm
checksum_type: sha256
description:
  Keywords: BlurHash, AVIF, image processing, Python, base64, PNG, data URL, image optimization, web performance, placeholder images


pkgId: 554fa4b6961310f3e384264486c01669cfd903d488d64d40b89f6024344d5baf
name: python-blurry-cli
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: A Mistune-based static site generator for Python
url: https://github.com/blurry-dev/blurry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blurry-cli-0.9.1-1.src.rpm
checksum_type: sha256
description:
  [![Nox build status](https://github.com/blurry-dev/blurry/actions/workflows/github-actions-nox.yml/badge.svg?branch=main)](https://github.com/blurry-dev/blurry/actions/workflows/github-actions-nox.yml)
  [![PyPI package version](https://img.shields.io/pypi/v/blurry-cli.svg)](https://pypi.org/project/blurry-cli/)
  [![PyPI Python versions](https://img.shields.io/pypi/pyversions/blurry-cli.svg)](https://pypi.org/project/blurry-cli/)
  ![Package license](https://img.shields.io/github/license/blurry-dev/blurry.svg)

  ![Blurry logo](docs/content/favicon.png)



  Blurry is a schema-first, plugin-enabled static site generator.
  Markdown front matter directly to [Schema.org types](https://schema.org/docs/full.html), so your content is SEO-friendly and [rich results-ready](https://developers.google.com/search/docs/appearance/structured-data/search-gallery) out of the box.

  Blurry also makes your images responsive, supports embedding Python source code in Markdown files, and more.

  Check out the docs and try it out!



  View the documentation site at <https://blurry-docs.netlify.app/>.



  Contributions are welcome!
  Check out [the contribution docs](https://github.com/blurry-dev/blurry/blob/main/CONTRIBUTING.md) to get started.



  Blurry blends together high-quality libraries:

  - [Mistune](https://mistune.readthedocs.io/) to convert Markdown to HTML
  - [Jinja](https://jinja.palletsprojects.com/) for HTML templating
  - [LiveReload](https://livereload.readthedocs.io/) for an HTTP server with automatic browser reloading
  - [Typer](https://typer.tiangolo.com/) for its CLI interface
  - [ImageMagick](https://imagemagick.org/index.php) to resize and convert images

  &copy; 2020-present, John Franey


pkgId: 48a8c20f601e2e0d49472dbe7d690262680290d930d05c292acd25bf067f3eba
name: python-bm
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Simple command line bookmark and/or tagging utility.
url: https://github.com/cym13/bookmark
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bm-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Simple command line bookmark and/or tagging utility.
  In order to help using it to tag files and directories as well as urls, it
  recognises if the URL given is that of an existing file. If so, the absolute
  path is substituted to help scripting by piping the output and to escape
  ambiguity. This behaviour can be stopped by using the "--no-path-subs" option.
  One way to see this program is to consider it a simple hashmap utility for
  bash that associates a set of strings (the tags) to another one (the url).
  Feel free to find other ways to use this program!
  Msgpack is used as is it highly portable, language agnostic and yet highly
  efficient.
  This script is written using python3.
  THIS VERSION IS STABLE.


pkgId: f0673d272ad8caf7756168c1d351b433c06de3cc3ba812e5c6330ff6873265f7
name: python-bm25s
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: An ultra-fast implementation of BM25 based on sparse matrices.
url: https://github.com/xhluca/bm25s
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bm25s-0.2.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <h1>BM25-Sparse⚡</h1>

  <i>BM25S is an ultrafast implementation of BM25 in pure Python, powered by Scipy sparse matrices</i>

  <table>
        <tr>
              <td>
                    <a href="https://github.com/xhluca/bm25s">💻 GitHub</a>
              </td>
              <td>
                    <a href="https://bm25s.github.io">🏠 Homepage</a>
              </td>
              <td>
                    <a href="https://arxiv.org/abs/2407.03618">📝 Technical Report</a>
              </td>
              <td>
                    <a href="https://huggingface.co/blog/xhluca/bm25s">🤗 Blog Post</a>
              </td>
        </tr>
  </table>

  </div>

  Welcome to `bm25s`, a library that implements BM25 in Python, allowing you to rank documents based on a query. BM25 is a widely used ranking function used for text retrieval tasks, and is a core component of search services like Elasticsearch.

  It is designed to be:
  * **Fast**: `bm25s` is implemented in pure Python and leverage Scipy sparse matrices to store eagerly computed scores for all document tokens. This allows extremely fast scoring at query time, improving performance over popular libraries by orders of magnitude (see benchmarks below).
  * **Simple**: `bm25s` is designed to be easy to use and understand. You can install it with pip and start using it in minutes. There is no dependencies on Java or Pytorch - all you need is Scipy and Numpy, and optional lightweight dependencies for stemming.

  Below, we compare `bm25s` with Elasticsearch in terms of speedup over `rank-bm25`, the most popular Python implementation of BM25. We measure the throughput in queries per second (QPS) on a few popular datasets from [BEIR](https://github.com/beir-cellar/beir) in a single-threaded setting.

  ![comparison](assets/comparison.png)

  <details>
  <summary>Click to show citation</summary><br>

  ```
  @misc{bm25s,
        title={BM25S: Orders of magnitude faster lexical search via eager sparse scoring},
        author={Xing Han Lù},
        year={2024},
        eprint={2407.03618},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.03618},
  }
  ```

  </details>

  > [!IMPORTANT]
  > BM25S just got faster! We are currently testing out integration with numba, which would make it up to [2x faster for larger datasets](https://github.com/xhluca/bm25-benchmarks?tab=readme-ov-file#queries-per-second)! Learn more about it and share your thoughts in [this discussion thread](https://github.com/xhluca/bm25s/discussions/46).



  You can install `bm25s` with pip:

  ```bash
  pip install bm25s
  ```

  If you want to use stemming for better results, you can install the recommended (but optional) dependencies:

  ```bash

  pip install bm25s[full]


  pip install PyStemmer


  pip install jax[cpu]
  ```



  Here is a simple example of how to use `bm25s`:

  ```python
  import bm25s
  import Stemmer  # optional: for stemming


  corpus = [
      "a cat is a feline and likes to purr",
      "a dog is the human's best friend and loves to play",
      "a bird is a beautiful animal that can fly",
      "a fish is a creature that lives in water and swims",
  ]


  stemmer = Stemmer.Stemmer("english")


  corpus_tokens = bm25s.tokenize(corpus, stopwords="en", stemmer=stemmer)


  retriever = bm25s.BM25()
  retriever.index(corpus_tokens)


  query = "does the fish purr like a cat?"
  query_tokens = bm25s.tokenize(query, stemmer=stemmer)


  results, scores = retriever.retrieve(query_tokens, corpus=corpus, k=2)

  for i in range(results.shape[1]):
      doc, score = results[0, i], scores[0, i]
      print(f"Rank {i+1} (score: {score:.2f}): {doc}")


  retriever.save("animal_index_bm25")


  retriever.save("animal_index_bm25", corpus=corpus)


  import bm25s
  reloaded_retriever = bm25s.BM25.load("animal_index_bm25", load_corpus=True)

  ```

  For an example that shows how to quickly index a 2M-documents corpus (Natural Questions), check out [`examples/index_nq.py`](examples/index_nq.py).



  `bm25s` provides a flexible API that allows you to customize the BM25 model and the tokenization process. Here are some of the options you can use:

  ```python

  queries = ["What is a cat?", "is the bird a dog?"]


  stopwords = ["a", "the"]


  stemmer_fn = lambda lst: [word for word in lst]


  query_token_ids = bm25s.tokenize(queries, stopwords=stopwords, stemmer=stemmer_fn)


  query_token_strs = bm25s.tokenize(queries, return_ids=False)


  titles = ["About Cat", "About Dog", "About Bird", "About Fish"]


  results = retriever.retrieve(query_token_ids, corpus=titles, k=2, return_as="documents")


  for i in range(results.shape[1]):
      print(f"Rank {i+1}: {results[0, i]}")
  ```



  `bm25s` is designed to be memory efficient. You can use the `mmap` option to load the BM25 index as a memory-mapped file, which allows you to load the index without loading the full index into memory. This is useful when you have a large index and want to save memory:

  ```python




  corpus = [
      "a very long document that is very long and has many words",
      "another long document that is long and has many words",
      
  ]

  retriever.save("bm25s_very_big_index", corpus=corpus)



  retriever = bm25s.BM25.load("bm25s_very_big_index", mmap=True)
  ```

  For an example of how to use retrieve using the `mmap=True` mode, check out [`examples/retrieve_nq.py`](examples/retrieve_nq.py).




  In addition to using the simple function `bm25s.tokenize`, you can also use the `Tokenizer` class to customize the tokenization process. This is useful when you want to use a different tokenizer, or when you want to use a different tokenization process for queries and documents:

  ```python
  from bm25s.tokenization import Tokenizer

  corpus = [
        "a cat is a feline and likes to purr",
        "a dog is the human's best friend and loves to play",
        "a bird is a beautiful animal that can fly",
        "a fish is a creature that lives in water and swims",
  ]


  stemmer = None
  stopwords = []
  splitter = lambda x: x.split() # function or regex pattern

  tokenizer = Tokenizer(
        stemmer=stemmer, stopwords=stopwords, splitter=splitter
  )

  corpus_tokens = tokenizer.tokenize(corpus)


  print("tokens:", corpus_tokens)
  print("vocab:", tokenizer.get_vocab_dict())


  ```

  You can find advanced examples in [examples/tokenizer_class.py](examples/tokenizer_class.py), including how to:
  * Pass a stemmer, stopwords, and splitter function/regex pattern
  * Control whether vocabulary is updated by `tokenizer.tokenize` calls or not (by default, it will only be updated during the first call)
  * Reset the tokenizer to its initial state with `tokenizer.reset_vocab()`
  * Use the tokenizer in generator mode to save memory by `yield`ing one document at a time.
  * Pass different outputs of the tokenizer to the `BM25.retrieve` function.





  You can use the following variants of BM25 in `bm25s` (see [Kamphuis et al. 2020](https://link.springer.com/chapter/10.1007/978-3-030-45442-5_4) for more details):

  * Original implementation (`method="robertson"`) - we set `idf>=0` to avoid negatives
  * ATIRE (`method="atire"`)
  * BM25L (`method="bm25l"`)
  * BM25+ (`method="bm25+"`)
  * Lucene (`method="lucene"`)

  By default, `bm25s` uses `method="lucene"`, which is Lucene's BM25 implementation (exact version). You can change the method by passing the `method` argument to the `BM25` constructor:

  ```python

  retriever = bm25s.BM25(method="robertson", k1=1.5, b=0.75)


  retriever = bm25s.BM25(method="bm25+", delta=1.5)



  retriever = bm25s.BM25(method="atire", idf_method="robertson")

  retriever = bm25s.BM25(method="atire", idf_method="lucene")
  ```



  `bm25` can naturally work with Hugging Face's `huggingface_hub`, allowing you to load and save to the model hub. This is useful for sharing BM25 indices and using community models.

  First, make sure you have a valid [access token for the Hugging Face model hub](https://huggingface.co/settings/tokens). This is needed to save models to the hub, or to load private models. Once you created it, you can add it to your environment variables (e.g. in your `.bashrc` or `.zshrc`):

  ```bash
  export HUGGING_FACE_HUB_TOKEN="hf_..."
  ```

  Now, let's install the `huggingface_hub` library:

  ```bash
  pip install huggingface_hub
  ```

  Let's see how to use `BM25SHF.save_to_hub` to save a BM25 index to the Hugging Face model hub:

  ```python
  import os
  import bm25s
  from bm25s.hf import BM25HF


  retriever = BM25HF()

  corpus = [
      "a cat is a feline and likes to purr",
      "a dog is the human's best friend and loves to play",
      "a bird is a beautiful animal that can fly",
      "a fish is a creature that lives in water and swims",
  ]
  corpus_tokens = bm25s.tokenize(corpus)
  retriever.index(corpus_tokens)


  user = "your-username"
  token = os.environ["HF_TOKEN"]
  retriever.save_to_hub(f"{user}/bm25s-animals", token=token, corpus=corpus)

  ```

  Then, you can use the following code to load a BM25 index from the Hugging Face model hub:

  ```python
  import bm25s
  from bm25s.hf import BM25HF


  user = "your-username"
  retriever = BM25HF.load_from_hub(f"{user}/bm25s-animals")


  retriever = BM25HF.load_from_hub(
      f"{user}/bm25s-animals", revision="main", load_corpus=True
  )


  retriever = BM25HF.load_from_hub(
      f"{user}/bm25s-animals", load_corpus=True, mmap=True
  )


  query = "does the fish purr like a cat?"


  query_tokens = bm25s.tokenize(query)


  results, scores = retriever.retrieve(query_tokens, k=2)
  ```

  For a complete example, check out:
  * [`examples/index_to_hf.py`](examples/index_to_hf.py) for indexing a corpus and upload to Huggingface Hub
  * [`examples/retrieve_from_hf.py`](examples/retrieve_from_hf.py) for loading an index alongside corpus from Huggingface Hub and querying it.



  Here are some benchmarks comparing `bm25s` to other popular BM25 implementations. We compare the following implementations:
  * `bm25s`: Our implementation of BM25 in pure Python, powered by Scipy sparse matrices.
  * `rank-bm25` (`Rank`): A popular Python implementation of BM25.
  * `bm25_pt` (`PT`): A Pytorch implementation of BM25.
  * `elasticsearch` (`ES`): Elasticsearch with BM25 configurations.

  `OOM` means the implementation ran out of memory during the benchmark.



  We compare the throughput of the BM25 implementations on various datasets. The throughput is measured in queries per second (QPS), on a single-threaded Intel Xeon CPU @ 2.70GHz (found on Kaggle). For BM25S, we take the average of 10 runs. Instances exceeding 60 queries/s are in **bold**.

  | Dataset          |   BM25S | Elastic | BM25-PT | Rank-BM25 |
  | :--------------- | ------: | ------: | ------: | --------: |
  | arguana          |  **573.91** |   13.67 |  **110.51** |         2 |
  | climate-fever    |   13.09 |    4.02 |     OOM |      0.03 |
  | cqadupstack      |  **170.91** |   13.38 |     OOM |      0.77 |
  | dbpedia-entity   |   13.44 |   10.68 |     OOM |      0.11 |
  | fever            |   20.19 |    7.45 |     OOM |      0.06 |
  | fiqa             |  **507.03** |   16.96 |   20.52 |      4.46 |
  | hotpotqa         |   20.88 |    7.11 |     OOM |      0.04 |
  | msmarco          |    12.2 |   11.88 |     OOM |      0.07 |
  | nfcorpus         | **1196.16** |   45.84 |  256.67 |    **224.66** |
  | nq               |   41.85 |   12.16 |     OOM |       0.1 |
  | quora            |  **183.53** |    21.8 |    6.49 |      1.18 |
  | scidocs          |  **767.05** |   17.93 |   41.34 |      9.01 |
  | scifact          |  **952.92** |   20.81 |   **184.3** |      47.6 |
  | trec-covid       |   **85.64** |    7.34 |    3.73 |      1.48 |
  | webis-touche2020 |   **60.59** |   13.53 |     OOM |       1.1 |

  More detailed benchmarks can be found in the [bm25-benchmarks repo](https://github.com/xhluca/bm25-benchmarks).



  `bm25s` is designed to be lightweight. This means the total disk usage of the package is minimal, as it only requires wheels for `numpy` (18MB), `scipy` (37MB), and the package itself is less than 100KB. After installation, the full virtual environment takes more space than `rank-bm25` but less than `pyserini` and `bm25_pt`:

  | Package           | Disk Usage |
  | ----------------- | ---------- |
  | venv (no package) | 45MB       |
  | `rank-bm25`       | 99MB       |
  | `bm25s` (ours)    | 479MB      |
  | `bm25_pt`         | 5346MB     |
  | `pyserini`        | 6976MB     |
  | `elastic`         | 1183MB     |

  <details>
  <summary>Show Details</summary>

  The disk usage of the virtual environments is calculated using the following command:

  ```
  $ du -s *env-* --block-size=1MB
  6976    conda-env-pyserini
  5346    venv-bm25-pt
  479     venv-bm25s
  45      venv-empty
  99      venv-rank-bm25
  ```

  For `pyserini`, we use the [recommended installation](https://github.com/castorini/pyserini/blob/master/docs/installation.md) with conda environment to account for Java dependencies.

  </details>



  `bm25s` allows considerable memory saving through the use of *memory-mapping*, which allows the index to be stored on disk and loaded on demand.

  When testing with 6 arbitrary queries with an index built with MS MARCO (8.8M documents, 300M+ tokens), we have the following:

  | Method | Load Index (s) | Retrieval (s) | RAM usage (GB) |
  | ------ | ----------------- | ------------- | -------------- |
  | Memory-mapped | 0.62 | 0.18 | 0.90 |
  | In-memory | 11.41 | 0.74 | 10.56 |

  When you run `bm25s` on 1000 queries on the Natural Questions dataset (2M+ documents), the memory usage is over 50% lower than the in-memory version with trivial difference in speed. You can find more information in the [GitHub repository](https://github.com/xhluca/bm25s).



  * The multilingual stopwords are sourced from the [NLTK stopwords lists](https://github.com/nltk/nltk/blob/96ee715997e1c8d9148b6d8e1b32f412f31c7ff7/nltk/corpus/__init__.py#L315).
  * The numba implementation are inspired by numba implementations originally proposed by [baguetter](https://github.com/mixedbread-ai/baguetter) and [retriv](https://github.com/AmenRa/retriv).
  * The function `bm25s.utils.beir.evaluate` is taken from the [BEIR library](https://github.com/beir-cellar/beir). It follows the same license as the BEIR library, which is Apache 2.0.



  If you use `bm25s` in your work, please use the following bibtex:

  ```
  @misc{bm25s,
        title={BM25S: Orders of magnitude faster lexical search via eager sparse scoring},
        author={Xing Han Lù},
        year={2024},
        eprint={2407.03618},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.03618},
  }
  ```


pkgId: b1e374d9c78a49f2e645c3c9ef3b804917e8a4ae3be78b29046e513483da4a51
name: python-bm25s
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: An ultra-fast implementation of BM25 based on sparse matrices.
url: https://github.com/xhluca/bm25s
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bm25s-0.2.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <h1>BM25-Sparse⚡</h1>

  <i>BM25S is an ultrafast implementation of BM25 in pure Python, powered by Scipy sparse matrices</i>

  <table>
        <tr>
              <td>
                    <a href="https://github.com/xhluca/bm25s">💻 GitHub</a>
              </td>
              <td>
                    <a href="https://bm25s.github.io">🏠 Homepage</a>
              </td>
              <td>
                    <a href="https://arxiv.org/abs/2407.03618">📝 Technical Report</a>
              </td>
              <td>
                    <a href="https://huggingface.co/blog/xhluca/bm25s">🤗 Blog Post</a>
              </td>
        </tr>
  </table>

  </div>

  Welcome to `bm25s`, a library that implements BM25 in Python, allowing you to rank documents based on a query. BM25 is a widely used ranking function used for text retrieval tasks, and is a core component of search services like Elasticsearch.

  It is designed to be:
  * **Fast**: `bm25s` is implemented in pure Python and leverage Scipy sparse matrices to store eagerly computed scores for all document tokens. This allows extremely fast scoring at query time, improving performance over popular libraries by orders of magnitude (see benchmarks below).
  * **Simple**: `bm25s` is designed to be easy to use and understand. You can install it with pip and start using it in minutes. There is no dependencies on Java or Pytorch - all you need is Scipy and Numpy, and optional lightweight dependencies for stemming.

  Below, we compare `bm25s` with Elasticsearch in terms of speedup over `rank-bm25`, the most popular Python implementation of BM25. We measure the throughput in queries per second (QPS) on a few popular datasets from [BEIR](https://github.com/beir-cellar/beir) in a single-threaded setting.

  ![comparison](assets/comparison.png)

  <details>
  <summary>Click to show citation</summary><br>

  ```
  @misc{bm25s,
        title={BM25S: Orders of magnitude faster lexical search via eager sparse scoring},
        author={Xing Han Lù},
        year={2024},
        eprint={2407.03618},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.03618},
  }
  ```

  </details>

  > [!IMPORTANT]
  > New in version 0.2.0: We are rolling out support for a numba backend, which gives around [2x speedup for larger datasets](https://github.com/xhluca/bm25-benchmarks?tab=readme-ov-file#queries-per-second)! Learn more about it and share your thoughts in [the version 0.2.0 release thread](https://github.com/xhluca/bm25s/discussions/58).



  You can install `bm25s` with pip:

  ```bash
  pip install bm25s
  ```

  If you want to use stemming for better results, you can install the recommended (but optional) dependencies:

  ```bash

  pip install bm25s[full]


  pip install PyStemmer


  pip install jax[cpu]
  ```



  Here is a simple example of how to use `bm25s`:

  ```python
  import bm25s
  import Stemmer  # optional: for stemming


  corpus = [
      "a cat is a feline and likes to purr",
      "a dog is the human's best friend and loves to play",
      "a bird is a beautiful animal that can fly",
      "a fish is a creature that lives in water and swims",
  ]


  stemmer = Stemmer.Stemmer("english")


  corpus_tokens = bm25s.tokenize(corpus, stopwords="en", stemmer=stemmer)


  retriever = bm25s.BM25()
  retriever.index(corpus_tokens)


  query = "does the fish purr like a cat?"
  query_tokens = bm25s.tokenize(query, stemmer=stemmer)


  results, scores = retriever.retrieve(query_tokens, corpus=corpus, k=2)

  for i in range(results.shape[1]):
      doc, score = results[0, i], scores[0, i]
      print(f"Rank {i+1} (score: {score:.2f}): {doc}")


  retriever.save("animal_index_bm25")


  retriever.save("animal_index_bm25", corpus=corpus)


  import bm25s
  reloaded_retriever = bm25s.BM25.load("animal_index_bm25", load_corpus=True)

  ```

  For an example that shows how to quickly index a 2M-documents corpus (Natural Questions), check out [`examples/index_nq.py`](examples/index_nq.py).



  `bm25s` provides a flexible API that allows you to customize the BM25 model and the tokenization process. Here are some of the options you can use:

  ```python

  queries = ["What is a cat?", "is the bird a dog?"]


  stopwords = ["a", "the"]


  stemmer_fn = lambda lst: [word for word in lst]


  query_token_ids = bm25s.tokenize(queries, stopwords=stopwords, stemmer=stemmer_fn)


  query_token_strs = bm25s.tokenize(queries, return_ids=False)


  titles = ["About Cat", "About Dog", "About Bird", "About Fish"]


  results = retriever.retrieve(query_token_ids, corpus=titles, k=2, return_as="documents")


  for i in range(results.shape[1]):
      print(f"Rank {i+1}: {results[0, i]}")
  ```



  `bm25s` is designed to be memory efficient. You can use the `mmap` option to load the BM25 index as a memory-mapped file, which allows you to load the index without loading the full index into memory. This is useful when you have a large index and want to save memory:

  ```python




  corpus = [
      "a very long document that is very long and has many words",
      "another long document that is long and has many words",
      
  ]

  retriever.save("bm25s_very_big_index", corpus=corpus)



  retriever = bm25s.BM25.load("bm25s_very_big_index", mmap=True)
  ```

  For an example of how to use retrieve using the `mmap=True` mode, check out [`examples/retrieve_nq.py`](examples/retrieve_nq.py).




  In addition to using the simple function `bm25s.tokenize`, you can also use the `Tokenizer` class to customize the tokenization process. This is useful when you want to use a different tokenizer, or when you want to use a different tokenization process for queries and documents:

  ```python
  from bm25s.tokenization import Tokenizer

  corpus = [
        "a cat is a feline and likes to purr",
        "a dog is the human's best friend and loves to play",
        "a bird is a beautiful animal that can fly",
        "a fish is a creature that lives in water and swims",
  ]


  stemmer = None
  stopwords = ["is"]
  splitter = lambda x: x.split() # function or regex pattern

  tokenizer = Tokenizer(
        stemmer=stemmer, stopwords=stopwords, splitter=splitter
  )

  corpus_tokens = tokenizer.tokenize(corpus)


  print("tokens:", corpus_tokens)
  print("vocab:", tokenizer.get_vocab_dict())



  tokenizer.save_vocab(save_dir="bm25s_very_big_index")


  new_tokenizer = Tokenizer(stemmer=stemmer, stopwords=[], splitter=splitter)
  new_tokenizer.load_vocab("bm25s_very_big_index")
  print("vocab reloaded:", new_tokenizer.get_vocab_dict())


  print("stopwords before reload:", new_tokenizer.stopwords)
  tokenizer.save_stopwords(save_dir="bm25s_very_big_index")
  new_tokenizer.load_stopwords("bm25s_very_big_index")
  print("stopwords reloaded:", new_tokenizer.stopwords)
  ```

  You can find advanced examples in [examples/tokenizer_class.py](examples/tokenizer_class.py), including how to:
  * Pass a stemmer, stopwords, and splitter function/regex pattern
  * Control whether vocabulary is updated by `tokenizer.tokenize` calls or not (by default, it will only be updated during the first call)
  * Reset the tokenizer to its initial state with `tokenizer.reset_vocab()`
  * Use the tokenizer in generator mode to save memory by `yield`ing one document at a time.
  * Pass different outputs of the tokenizer to the `BM25.retrieve` function.





  You can use the following variants of BM25 in `bm25s` (see [Kamphuis et al. 2020](https://link.springer.com/chapter/10.1007/978-3-030-45442-5_4) for more details):

  * Original implementation (`method="robertson"`) - we set `idf>=0` to avoid negatives
  * ATIRE (`method="atire"`)
  * BM25L (`method="bm25l"`)
  * BM25+ (`method="bm25+"`)
  * Lucene (`method="lucene"`)

  By default, `bm25s` uses `method="lucene"`, which is Lucene's BM25 implementation (exact version). You can change the method by passing the `method` argument to the `BM25` constructor:

  ```python

  retriever = bm25s.BM25(method="robertson", k1=1.5, b=0.75)


  retriever = bm25s.BM25(method="bm25+", delta=1.5)



  retriever = bm25s.BM25(method="atire", idf_method="robertson")

  retriever = bm25s.BM25(method="atire", idf_method="lucene")
  ```



  `bm25` can naturally work with Hugging Face's `huggingface_hub`, allowing you to load and save to the model hub. This is useful for sharing BM25 indices and using community models.

  First, make sure you have a valid [access token for the Hugging Face model hub](https://huggingface.co/settings/tokens). This is needed to save models to the hub, or to load private models. Once you created it, you can add it to your environment variables (e.g. in your `.bashrc` or `.zshrc`):

  ```bash
  export HUGGING_FACE_HUB_TOKEN="hf_..."
  ```

  Now, let's install the `huggingface_hub` library:

  ```bash
  pip install huggingface_hub
  ```

  Let's see how to use `BM25SHF.save_to_hub` to save a BM25 index to the Hugging Face model hub:

  ```python
  import os
  import bm25s
  from bm25s.hf import BM25HF


  retriever = BM25HF()

  corpus = [
      "a cat is a feline and likes to purr",
      "a dog is the human's best friend and loves to play",
      "a bird is a beautiful animal that can fly",
      "a fish is a creature that lives in water and swims",
  ]
  corpus_tokens = bm25s.tokenize(corpus)
  retriever.index(corpus_tokens)


  user = "your-username"
  token = os.environ["HF_TOKEN"]
  retriever.save_to_hub(f"{user}/bm25s-animals", token=token, corpus=corpus)

  ```

  Then, you can use the following code to load a BM25 index from the Hugging Face model hub:

  ```python
  import bm25s
  from bm25s.hf import BM25HF


  user = "your-username"
  retriever = BM25HF.load_from_hub(f"{user}/bm25s-animals")


  retriever = BM25HF.load_from_hub(
      f"{user}/bm25s-animals", revision="main", load_corpus=True
  )


  retriever = BM25HF.load_from_hub(
      f"{user}/bm25s-animals", load_corpus=True, mmap=True
  )


  query = "does the fish purr like a cat?"


  query_tokens = bm25s.tokenize(query)


  results, scores = retriever.retrieve(query_tokens, k=2)
  ```

  For a complete example, check out:
  * [`examples/index_to_hf.py`](examples/index_to_hf.py) for indexing a corpus and upload to Huggingface Hub
  * [`examples/retrieve_from_hf.py`](examples/retrieve_from_hf.py) for loading an index alongside corpus from Huggingface Hub and querying it.



  Here are some benchmarks comparing `bm25s` to other popular BM25 implementations. We compare the following implementations:
  * `bm25s`: Our implementation of BM25 in pure Python, powered by Scipy sparse matrices.
  * `rank-bm25` (`Rank`): A popular Python implementation of BM25.
  * `bm25_pt` (`PT`): A Pytorch implementation of BM25.
  * `elasticsearch` (`ES`): Elasticsearch with BM25 configurations.

  `OOM` means the implementation ran out of memory during the benchmark.



  We compare the throughput of the BM25 implementations on various datasets. The throughput is measured in queries per second (QPS), on a single-threaded Intel Xeon CPU @ 2.70GHz (found on Kaggle). For BM25S, we take the average of 10 runs. Instances exceeding 60 queries/s are in **bold**.

  | Dataset          |       BM25S | Elastic |    BM25-PT |  Rank-BM25 |
  | :--------------- | ----------: | ------: | ---------: | ---------: |
  | arguana          |  **573.91** |   13.67 | **110.51** |          2 |
  | climate-fever    |       13.09 |    4.02 |        OOM |       0.03 |
  | cqadupstack      |  **170.91** |   13.38 |        OOM |       0.77 |
  | dbpedia-entity   |       13.44 |   10.68 |        OOM |       0.11 |
  | fever            |       20.19 |    7.45 |        OOM |       0.06 |
  | fiqa             |  **507.03** |   16.96 |      20.52 |       4.46 |
  | hotpotqa         |       20.88 |    7.11 |        OOM |       0.04 |
  | msmarco          |        12.2 |   11.88 |        OOM |       0.07 |
  | nfcorpus         | **1196.16** |   45.84 |     256.67 | **224.66** |
  | nq               |       41.85 |   12.16 |        OOM |        0.1 |
  | quora            |  **183.53** |    21.8 |       6.49 |       1.18 |
  | scidocs          |  **767.05** |   17.93 |      41.34 |       9.01 |
  | scifact          |  **952.92** |   20.81 |  **184.3** |       47.6 |
  | trec-covid       |   **85.64** |    7.34 |       3.73 |       1.48 |
  | webis-touche2020 |   **60.59** |   13.53 |        OOM |        1.1 |

  More detailed benchmarks can be found in the [bm25-benchmarks repo](https://github.com/xhluca/bm25-benchmarks).



  `bm25s` is designed to be lightweight. This means the total disk usage of the package is minimal, as it only requires wheels for `numpy` (18MB), `scipy` (37MB), and the package itself is less than 100KB. After installation, the full virtual environment takes more space than `rank-bm25` but less than `pyserini` and `bm25_pt`:

  | Package           | Disk Usage |
  | ----------------- | ---------- |
  | venv (no package) | 45MB       |
  | `rank-bm25`       | 99MB       |
  | `bm25s` (ours)    | 479MB      |
  | `bm25_pt`         | 5346MB     |
  | `pyserini`        | 6976MB     |
  | `elastic`         | 1183MB     |

  <details>
  <summary>Show Details</summary>

  The disk usage of the virtual environments is calculated using the following command:

  ```
  $ du -s *env-* --block-size=1MB
  6976    conda-env-pyserini
  5346    venv-bm25-pt
  479     venv-bm25s
  45      venv-empty
  99      venv-rank-bm25
  ```

  For `pyserini`, we use the [recommended installation](https://github.com/castorini/pyserini/blob/master/docs/installation.md) with conda environment to account for Java dependencies.

  </details>



  `bm25s` allows considerable memory saving through the use of *memory-mapping*, which allows the index to be stored on disk and loaded on demand.

  Using the `index_nq.py` to create an index, we can retrieve with:
  * `examples/retrieve_nq.py`: setting `mmap=False` in the `main` function to load the index in memory, and `mmap=True` to load the index as a memory-mapped file.
  * `examples/retrieve_nq_with_batching.py`: This takes it a step further by batching the retrieval process, which allows for reloading the index after each batch (see *Mmap+Reload* below). This is useful when you have a large index and want to save memory.

  we show the following results on the NQ dataset (2M+ documents, 100M+ tokens):

  | Method        | Load Index (s) | Retrieval (s) | RAM post-index (GB) | RAM post-retrieve (GB) |
  | ------------- | -------------- | ------------- | ------------------- | ---------------------- |
  | In-memory     | 8.61           | 21.09         | 4.36                | 4.45                   |
  | Memory-mapped | 0.53           | 20.22         | 0.49                | 2.16                   |
  | Mmap+Reload   | 0.48           | 20.96         | 0.49                | 0.70                   |

  We can see that memory-mapping the index allows for a significant reduction in memory usage, with comparable retrieval times.

  Similarly, for MSMARCO (8M+ documents, 300M+ tokens), we show the following results (running on the validation set), although the retrieval did not complete for the in-memory case (* denotes that the retrieval did not terminate):

  | Method        | Load Index (s) | Retrieval (s) | RAM post-index (GB) | RAM post-retrieve (GB) |
  | ------------- | -------------- | ------------- | ------------------- | ---------------------- |
  | In-memory     | 25.71          | 93.66         | 10.21               | 10.34                  |
  | Memory-mapped | 1.24           | 90.41         | 1.14                | 4.88                   |
  | Mmap+Reload   | 1.17           | 97.89         | 1.14                | 1.38                   |



  * The multilingual stopwords are sourced from the [NLTK stopwords lists](https://github.com/nltk/nltk/blob/96ee715997e1c8d9148b6d8e1b32f412f31c7ff7/nltk/corpus/__init__.py#L315).
  * The numba implementation are inspired by numba implementations originally proposed by [baguetter](https://github.com/mixedbread-ai/baguetter) and [retriv](https://github.com/AmenRa/retriv).
  * The function `bm25s.utils.beir.evaluate` is taken from the [BEIR library](https://github.com/beir-cellar/beir). It follows the same license as the BEIR library, which is Apache 2.0.



  If you use `bm25s` in your work, please use the following bibtex:

  ```
  @misc{bm25s,
        title={BM25S: Orders of magnitude faster lexical search via eager sparse scoring},
        author={Xing Han Lù},
        year={2024},
        eprint={2407.03618},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.03618},
  }
  ```


pkgId: f2c0155bef17fc7476f6939414589ad5233fd79a701f18e34f34c8e6a04a5ddf
name: python-bm25s
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: An ultra-fast implementation of BM25 based on sparse matrices.
url: https://github.com/xhluca/bm25s
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bm25s-0.2.5-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <h1>BM25-Sparse⚡</h1>

  <i>BM25S is an ultrafast implementation of BM25 in pure Python, powered by Scipy sparse matrices</i>

  <table>
        <tr>
              <td>
                    <a href="https://github.com/xhluca/bm25s">💻 GitHub</a>
              </td>
              <td>
                    <a href="https://bm25s.github.io">🏠 Homepage</a>
              </td>
              <td>
                    <a href="https://arxiv.org/abs/2407.03618">📝 Technical Report</a>
              </td>
              <td>
                    <a href="https://huggingface.co/blog/xhluca/bm25s">🤗 Blog Post</a>
              </td>
              <td>
                    <a href="#installation">🛠️ Installation</a>
              </td>
        </tr>
  </table>

  </div>

  Welcome to `bm25s`, a library that implements BM25 in Python, allowing you to rank documents based on a query. BM25 is a widely used ranking function used for text retrieval tasks, and is a core component of search services like Elasticsearch.

  It is designed to be:
  * **Fast**: `bm25s` is implemented in pure Python and leverage Scipy sparse matrices to store eagerly computed scores for all document tokens. This allows extremely fast scoring at query time, improving performance over popular libraries by orders of magnitude (see benchmarks below).
  * **Simple**: `bm25s` is designed to be easy to use and understand. You can install it with pip and start using it in minutes. There is no dependencies on Java or Pytorch - all you need is Scipy and Numpy, and optional lightweight dependencies for stemming.

  Below, we compare `bm25s` with Elasticsearch in terms of speedup over `rank-bm25`, the most popular Python implementation of BM25. We measure the throughput in queries per second (QPS) on a few popular datasets from [BEIR](https://github.com/beir-cellar/beir) in a single-threaded setting.

  ![comparison](assets/comparison.png)

  > [!IMPORTANT]
  > New in version 0.2.0: We are rolling out support for a numba backend, which gives around [2x speedup for larger datasets](https://github.com/xhluca/bm25-benchmarks?tab=readme-ov-file#queries-per-second)! Learn more about it and share your thoughts in [the version 0.2.0 release thread](https://github.com/xhluca/bm25s/discussions/58).


  <details open>
  <summary>Show/Hide citation</summary><br>

  ```
  @misc{bm25s,
        title={BM25S: Orders of magnitude faster lexical search via eager sparse scoring},
        author={Xing Han Lù},
        year={2024},
        eprint={2407.03618},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.03618},
  }
  ```

  </details>



  You can install `bm25s` with pip:

  ```bash
  pip install bm25s
  ```

  If you want to use stemming for better results, you can install the recommended (but optional) dependencies:

  ```bash

  pip install bm25s[full]


  pip install PyStemmer


  pip install jax[cpu]
  ```



  Here is a simple example of how to use `bm25s`:

  ```python
  import bm25s
  import Stemmer  # optional: for stemming


  corpus = [
      "a cat is a feline and likes to purr",
      "a dog is the human's best friend and loves to play",
      "a bird is a beautiful animal that can fly",
      "a fish is a creature that lives in water and swims",
  ]


  stemmer = Stemmer.Stemmer("english")


  corpus_tokens = bm25s.tokenize(corpus, stopwords="en", stemmer=stemmer)


  retriever = bm25s.BM25()
  retriever.index(corpus_tokens)


  query = "does the fish purr like a cat?"
  query_tokens = bm25s.tokenize(query, stemmer=stemmer)



  results, scores = retriever.retrieve(query_tokens, k=2)

  for i in range(results.shape[1]):
      doc, score = results[0, i], scores[0, i]
      print(f"Rank {i+1} (score: {score:.2f}): {doc}")


  retriever.save("animal_index_bm25")


  retriever.save("animal_index_bm25", corpus=corpus)


  import bm25s
  reloaded_retriever = bm25s.BM25.load("animal_index_bm25", load_corpus=True)

  ```

  For an example that shows how to quickly index a 2M-documents corpus (Natural Questions), check out [`examples/index_nq.py`](examples/index_nq.py).



  `bm25s` provides a flexible API that allows you to customize the BM25 model and the tokenization process. Here are some of the options you can use:

  ```python

  queries = ["What is a cat?", "is the bird a dog?"]


  stopwords = ["a", "the"]


  stemmer_fn = lambda lst: [word for word in lst]


  query_token_ids = bm25s.tokenize(queries, stopwords=stopwords, stemmer=stemmer_fn)


  query_token_strs = bm25s.tokenize(queries, return_ids=False)


  titles = ["About Cat", "About Dog", "About Bird", "About Fish"]


  results = retriever.retrieve(query_token_ids, corpus=titles, k=2, return_as="documents")


  for i in range(results.shape[1]):
      print(f"Rank {i+1}: {results[0, i]}")
  ```



  `bm25s` is designed to be memory efficient. You can use the `mmap` option to load the BM25 index as a memory-mapped file, which allows you to load the index without loading the full index into memory. This is useful when you have a large index and want to save memory:

  ```python




  corpus = [
      "a very long document that is very long and has many words",
      "another long document that is long and has many words",
      
  ]

  retriever.save("bm25s_very_big_index", corpus=corpus)



  retriever = bm25s.BM25.load("bm25s_very_big_index", mmap=True)
  ```

  For an example of how to use retrieve using the `mmap=True` mode, check out [`examples/retrieve_nq.py`](examples/retrieve_nq.py).




  In addition to using the simple function `bm25s.tokenize`, you can also use the `Tokenizer` class to customize the tokenization process. This is useful when you want to use a different tokenizer, or when you want to use a different tokenization process for queries and documents:

  ```python
  from bm25s.tokenization import Tokenizer

  corpus = [
        "a cat is a feline and likes to purr",
        "a dog is the human's best friend and loves to play",
        "a bird is a beautiful animal that can fly",
        "a fish is a creature that lives in water and swims",
  ]


  stemmer = None
  stopwords = ["is"]
  splitter = lambda x: x.split() # function or regex pattern

  tokenizer = Tokenizer(
        stemmer=stemmer, stopwords=stopwords, splitter=splitter
  )

  corpus_tokens = tokenizer.tokenize(corpus)


  print("tokens:", corpus_tokens)
  print("vocab:", tokenizer.get_vocab_dict())



  tokenizer.save_vocab(save_dir="bm25s_very_big_index")


  new_tokenizer = Tokenizer(stemmer=stemmer, stopwords=[], splitter=splitter)
  new_tokenizer.load_vocab("bm25s_very_big_index")
  print("vocab reloaded:", new_tokenizer.get_vocab_dict())


  print("stopwords before reload:", new_tokenizer.stopwords)
  tokenizer.save_stopwords(save_dir="bm25s_very_big_index")
  new_tokenizer.load_stopwords("bm25s_very_big_index")
  print("stopwords reloaded:", new_tokenizer.stopwords)
  ```

  You can find advanced examples in [examples/tokenizer_class.py](examples/tokenizer_class.py), including how to:
  * Pass a stemmer, stopwords, and splitter function/regex pattern
  * Control whether vocabulary is updated by `tokenizer.tokenize` calls or not (by default, it will only be updated during the first call)
  * Reset the tokenizer to its initial state with `tokenizer.reset_vocab()`
  * Use the tokenizer in generator mode to save memory by `yield`ing one document at a time.
  * Pass different outputs of the tokenizer to the `BM25.retrieve` function.





  You can use the following variants of BM25 in `bm25s` (see [Kamphuis et al. 2020](https://link.springer.com/chapter/10.1007/978-3-030-45442-5_4) for more details):

  * Original implementation (`method="robertson"`) - we set `idf>=0` to avoid negatives
  * ATIRE (`method="atire"`)
  * BM25L (`method="bm25l"`)
  * BM25+ (`method="bm25+"`)
  * Lucene (`method="lucene"`)

  By default, `bm25s` uses `method="lucene"`, which is Lucene's BM25 implementation (exact version). You can change the method by passing the `method` argument to the `BM25` constructor:

  ```python

  retriever = bm25s.BM25(method="robertson", k1=1.5, b=0.75)


  retriever = bm25s.BM25(method="bm25+", delta=1.5)



  retriever = bm25s.BM25(method="atire", idf_method="robertson")

  retriever = bm25s.BM25(method="atire", idf_method="lucene")
  ```



  `bm25` can naturally work with Hugging Face's `huggingface_hub`, allowing you to load and save to the model hub. This is useful for sharing BM25 indices and using community models.

  First, make sure you have a valid [access token for the Hugging Face model hub](https://huggingface.co/settings/tokens). This is needed to save models to the hub, or to load private models. Once you created it, you can add it to your environment variables (e.g. in your `.bashrc` or `.zshrc`):

  ```bash
  export HUGGING_FACE_HUB_TOKEN="hf_..."
  ```

  Now, let's install the `huggingface_hub` library:

  ```bash
  pip install huggingface_hub
  ```

  Let's see how to use `BM25SHF.save_to_hub` to save a BM25 index to the Hugging Face model hub:

  ```python
  import os
  import bm25s
  from bm25s.hf import BM25HF


  retriever = BM25HF()

  corpus = [
      "a cat is a feline and likes to purr",
      "a dog is the human's best friend and loves to play",
      "a bird is a beautiful animal that can fly",
      "a fish is a creature that lives in water and swims",
  ]
  corpus_tokens = bm25s.tokenize(corpus)
  retriever.index(corpus_tokens)


  user = "your-username"
  token = os.environ["HF_TOKEN"]
  retriever.save_to_hub(f"{user}/bm25s-animals", token=token, corpus=corpus)

  ```

  Then, you can use the following code to load a BM25 index from the Hugging Face model hub:

  ```python
  import bm25s
  from bm25s.hf import BM25HF


  user = "your-username"
  retriever = BM25HF.load_from_hub(f"{user}/bm25s-animals")


  retriever = BM25HF.load_from_hub(
      f"{user}/bm25s-animals", revision="main", load_corpus=True
  )


  retriever = BM25HF.load_from_hub(
      f"{user}/bm25s-animals", load_corpus=True, mmap=True
  )


  query = "does the fish purr like a cat?"


  query_tokens = bm25s.tokenize(query)


  results, scores = retriever.retrieve(query_tokens, k=2)
  ```

  For a complete example, check out:
  * [`examples/index_to_hf.py`](examples/index_to_hf.py) for indexing a corpus and upload to Huggingface Hub
  * [`examples/retrieve_from_hf.py`](examples/retrieve_from_hf.py) for loading an index alongside corpus from Huggingface Hub and querying it.



  Here are some benchmarks comparing `bm25s` to other popular BM25 implementations. We compare the following implementations:
  * `bm25s`: Our implementation of BM25 in pure Python, powered by Scipy sparse matrices.
  * `rank-bm25` (`Rank`): A popular Python implementation of BM25.
  * `bm25_pt` (`PT`): A Pytorch implementation of BM25.
  * `elasticsearch` (`ES`): Elasticsearch with BM25 configurations.

  `OOM` means the implementation ran out of memory during the benchmark.



  We compare the throughput of the BM25 implementations on various datasets. The throughput is measured in queries per second (QPS), on a single-threaded Intel Xeon CPU @ 2.70GHz (found on Kaggle). For BM25S, we take the average of 10 runs. Instances exceeding 60 queries/s are in **bold**.

  | Dataset          |       BM25S | Elastic |    BM25-PT |  Rank-BM25 |
  | :--------------- | ----------: | ------: | ---------: | ---------: |
  | arguana          |  **573.91** |   13.67 | **110.51** |          2 |
  | climate-fever    |       13.09 |    4.02 |        OOM |       0.03 |
  | cqadupstack      |  **170.91** |   13.38 |        OOM |       0.77 |
  | dbpedia-entity   |       13.44 |   10.68 |        OOM |       0.11 |
  | fever            |       20.19 |    7.45 |        OOM |       0.06 |
  | fiqa             |  **507.03** |   16.96 |      20.52 |       4.46 |
  | hotpotqa         |       20.88 |    7.11 |        OOM |       0.04 |
  | msmarco          |        12.2 |   11.88 |        OOM |       0.07 |
  | nfcorpus         | **1196.16** |   45.84 |     256.67 | **224.66** |
  | nq               |       41.85 |   12.16 |        OOM |        0.1 |
  | quora            |  **183.53** |    21.8 |       6.49 |       1.18 |
  | scidocs          |  **767.05** |   17.93 |      41.34 |       9.01 |
  | scifact          |  **952.92** |   20.81 |  **184.3** |       47.6 |
  | trec-covid       |   **85.64** |    7.34 |       3.73 |       1.48 |
  | webis-touche2020 |   **60.59** |   13.53 |        OOM |        1.1 |

  More detailed benchmarks can be found in the [bm25-benchmarks repo](https://github.com/xhluca/bm25-benchmarks).



  `bm25s` is designed to be lightweight. This means the total disk usage of the package is minimal, as it only requires wheels for `numpy` (18MB), `scipy` (37MB), and the package itself is less than 100KB. After installation, the full virtual environment takes more space than `rank-bm25` but less than `pyserini` and `bm25_pt`:

  | Package           | Disk Usage |
  | ----------------- | ---------- |
  | venv (no package) | 45MB       |
  | `rank-bm25`       | 99MB       |
  | `bm25s` (ours)    | 479MB      |
  | `bm25_pt`         | 5346MB     |
  | `pyserini`        | 6976MB     |
  | `elastic`         | 1183MB     |

  <details>
  <summary>Show Details</summary>

  The disk usage of the virtual environments is calculated using the following command:

  ```
  $ du -s *env-* --block-size=1MB
  6976    conda-env-pyserini
  5346    venv-bm25-pt
  479     venv-bm25s
  45      venv-empty
  99      venv-rank-bm25
  ```

  For `pyserini`, we use the [recommended installation](https://github.com/castorini/pyserini/blob/master/docs/installation.md) with conda environment to account for Java dependencies.

  </details>



  `bm25s` allows considerable memory saving through the use of *memory-mapping*, which allows the index to be stored on disk and loaded on demand.

  Using the `index_nq.py` to create an index, we can retrieve with:
  * `examples/retrieve_nq.py`: setting `mmap=False` in the `main` function to load the index in memory, and `mmap=True` to load the index as a memory-mapped file.
  * `examples/retrieve_nq_with_batching.py`: This takes it a step further by batching the retrieval process, which allows for reloading the index after each batch (see *Mmap+Reload* below). This is useful when you have a large index and want to save memory.

  We show the following results on the NQ dataset (2M+ documents, 100M+ tokens):

  | Method        | Load Index (s) | Retrieval (s) | RAM post-index (GB) | RAM post-retrieve (GB) |
  | ------------- | -------------- | ------------- | ------------------- | ---------------------- |
  | In-memory     | 8.61           | 21.09         | 4.36                | 4.45                   |
  | Memory-mapped | 0.53           | 20.22         | 0.49                | 2.16                   |
  | Mmap+Reload   | 0.48           | 20.96         | 0.49                | 0.70                   |

  We can see that memory-mapping the index allows for a significant reduction in memory usage, with comparable retrieval times.

  Similarly, for MSMARCO (8M+ documents, 300M+ tokens), we show the following results (running on the validation set), although the retrieval did not complete for the in-memory case:

  | Method        | Load Index (s) | Retrieval (s) | RAM post-index (GB) | RAM post-retrieve (GB) |
  | ------------- | -------------- | ------------- | ------------------- | ---------------------- |
  | In-memory     | 25.71          | 93.66         | 10.21               | 10.34                  |
  | Memory-mapped | 1.24           | 90.41         | 1.14                | 4.88                   |
  | Mmap+Reload   | 1.17           | 97.89         | 1.14                | 1.38                   |



  * The central idea behind the scoring mechanism in this library is originally from [bm25_pt](https://github.com/jxmorris12/bm25_pt), which was a major inspiration to this project.
  * The API of the [`BM25` class](https://github.com/xhluca/bm25s/blob/main/bm25s/__init__.py) is also heavily inspired by the design of BM25-pt, as well as that of rank-bm25.
  * The multilingual stopwords are sourced from the [NLTK stopwords lists](https://github.com/nltk/nltk/blob/96ee715997e1c8d9148b6d8e1b32f412f31c7ff7/nltk/corpus/__init__.py#L315).
  * The numba implementation are inspired by numba implementations originally proposed by [baguetter](https://github.com/mixedbread-ai/baguetter) and [retriv](https://github.com/AmenRa/retriv).
  * The function `bm25s.utils.beir.evaluate` is taken from the [BEIR library](https://github.com/beir-cellar/beir). It follows the same license as the BEIR library, which is Apache 2.0.



  If you use `bm25s` in your work, please use the following bibtex:

  ```
  @misc{bm25s,
        title={BM25S: Orders of magnitude faster lexical search via eager sparse scoring},
        author={Xing Han Lù},
        year={2024},
        eprint={2407.03618},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.03618},
  }
  ```


pkgId: 27aec6a5ec39bafb4a23821785e48c846383f17eaa05afb11cf17ec80a3f8f51
name: python-bm3d
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: BM3D for correlated noise
url: https://webpages.tuni.fi/foi/GCF-BM3D/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bm3d-4.0.3-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for BM3D for stationary correlated noise (including white noise) for color,
  grayscale and multichannel images and deblurring.

  BM3D is an algorithm for attenuation of additive spatially correlated
  stationary (aka colored) Gaussian noise. This package provides a wrapper
  for the BM3D binaries for use for grayscale, color and other multichannel images
  for denoising and deblurring.

  This implementation is based on
  - Y. Mäkinen, L. Azzari, A. Foi, 2020, "Collaborative Filtering of Correlated Noise: Exact Transform-Domain Variance
  for Improved Shrinkage and Patch Matching", in IEEE Transactions on Image Processing, vol. 29, pp. 8339-8354.
  - K. Dabov, A. Foi, V. Katkovnik, K. Egiazarian, 2007, "Image Denoising by Sparse 3-D Transform-Domain Collaborative
  Filtering", in IEEE Transactions on Image Processing, vol. 16, pp. 2080-2095.

  This package provides a BM3D interface for the "bm4d" denoising package. Please see the
  [bm4d](https://pypi.org/project/bm4d) package for supported platforms.

  The package is available for non-commercial use only. For details, see LICENSE.

  For examples, see the examples folder of the full source (bm3d-***.tar.gz) from https://pypi.org/project/bm3d/#files ,
  which also includes the example noise cases demonstrated in the paper.

  Authors: \
      Ymir Mäkinen <ymir.makinen@tuni.fi> \
      Lucio Azzari \
      Alessandro Foi


pkgId: 18afa3dd4a1b06cfe78d33415c4e2d580864bca257bce77d4ca1cbb306db38d9
name: python-bma
arch: src
version: 0.2.0a1
epoch: 0
release: 1
summary: BornHack Media Archive Django project
url: https://pypi.org/project/bma/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bma-0.2.0a1-1.src.rpm
checksum_type: sha256
description:
  [![Run Tox CI](https://github.com/bornhack/bma/actions/workflows/tox.yml/badge.svg?branch=develop)](https://github.com/bornhack/bma/actions/workflows/tox.yml)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![codecov](https://codecov.io/gh/bornhack/bma/graph/badge.svg?token=AN3NmaCDAr)](https://codecov.io/gh/bornhack/bma)


  BornHack Media Archive


  The BornHack Media Archive is a site for sharing pictures and video from BornHack events. It uses the BornHack website oauth2 provider for login.


  > Note! The server is using database functions not compatible with sqlite. Use postgresql instead.


  * Copy `bma/environment_settings.py.dist` to `bma/environment_settings.py` and either edit it directly, or use .env file or environment variables to configure.
      * Set `OAUTH_SERVER_BASEURL` to point to a local instance of the BornHack website eg. `http://127.0.0.1:8000`, or leave it pointing at the prod bornhack.dk server.
  * Create an oauth app on the BornHack instance you specified in `OAUTH_SERVER_BASEURL`:
      * login to the BornHack instance and go to the url `OAUTH_SERVER_BASEURL/o/applications`.
      * register a new app.
      * client type `confidential`
      * grant type `authorization code`
      * redirect uri's `BMA_BASEURL/accounts/bornhack/login/callback/` eg. `http://127.0.0.1:8001/accounts/bornhack/login/callback/`.
  * Run `manage.py migrate`
      * If you get a database error about missing 'gist', you need to run `create extension btree_gist;` on your postgresql instance.
  * Run `manage.py createsuperuser` to create a local database user in the BMA instance
  * Log in with the superuser and add a social app on the BMA admin website using the client id and secret from the bornhack website used in the above step.
  * Move `example.com` to `chosen sites`.


  It should now be possible to login to BMA using a BornHack account.


pkgId: 715a53da2f5e9892f34b9ac81e5e634a531acdb5774234f838273458f8fc7e14
name: python-bma-cli
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: BornHack Media Archive CLI Tool
url: https://pypi.org/project/bma-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bma-cli-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![PyPI version](https://badge.fury.io/py/bma-cli.svg)](https://pypi.org/project/bma-cli/)



  BMA CLI client written in Python

  Based on https://github.com/bornhack/bma-client-lib-python


pkgId: 6c877b108956c8ae953f5e37e6fc48b4864d94087f7c34c1815a812f373bc41a
name: python-bma-client-lib
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: BornHack Media Archive Client Library
url: https://pypi.org/project/bma-client-lib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bma-client-lib-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![PyPI version](https://badge.fury.io/py/bma-client-lib.svg)](https://pypi.org/project/bma-client-lib/)



  BMA client Python library

  Used by https://github.com/bornhack/bma-cli-python


pkgId: af8258e4a721b3c64fdff53ae6398f22242f8adc6e48bd861f5c9b950a913bbe
name: python-bmcs-utils
arch: src
version: 0.0.34a0
epoch: 0
release: 1
summary: Suite of utilities for to implementation of bmcs_utils for brittle-matrix composites.
url: https://github.com/bmcs-group/bmcs_utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmcs-utils-0.0.34a0-1.src.rpm
checksum_type: sha256
description:
  This repository contains development patterns
  applied for the bmcs packges. They distinguish
  three development phases:
   * Formulation of model components using using jupyter notebooks with Python package
   * Implementation of Python packages
   * Model presentation using examples via Jupyter Notebooks

  The detailed documentation of the package is provided
  [here](docs/README.md)


pkgId: ceb8e503ae4b522496f3af032b9433739b35114a753b36573a28dc627dadd33c
name: python-bmdf
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Embed commands, their output, and tables of contents in markdown
url: https://github.com/runsascoded/bash-markdown-fence
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmdf-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **B**ash **m**ark**d**own **f**ences: embed commands, their output, and tables of contents in markdown

  [![](https://img.shields.io/pypi/v/bmdf?label=bmdf&color=blue)][bmdf]

  <a id="toc"></a>
  <!-- toc -->
  - [Install](#install)
  - [Usage](#usage)
      - [`bmd`: format `bash` command and output as Markdown](#bmd)
          - [`bmdf` (`bmd -f`): command+output mode](#bmdf)
          - [`bmdff` (`bmd -ff`): two-fence mode](#bmdff)
          - [`bmdfff` (`bmd -fff`): &lt;details&gt; mode](#bmdfff)
      - [`mdcmd`: update commands embedded in Markdown files](#mdcmd)
      - [`mktoc`: update table of contents](#mktoc)
      - [Reference](#reference)
  - [Examples](#examples)
  <!-- /toc -->

  This package provides 3 CLIs:
  - `bmd`: run Bash commands, wrap output for Markdown embedding
    - [`bmdf`](#bmdf), [`bmdff`](#bmdff), [`bmdfff`](#bmdfff): different levels of "fencing" for command output
  - `mdcmd`: find `bmd` blocks in Markdown files, execute commands, update Markdown files with output
  - `mktoc`: update Markdown table of contents (with custom "id" anchors)


  ```bash
  pip install bmdf
  ```





  `bmd` (and aliases [`bmdf`](#bmdf), [`bmdff`](#bmdff), [`bmdfff`](#bmdfff)) takes a `bash` command as input, and renders the command and/or its output in various Markdown-friendly formats:



  Suppose you want to embed a command and its output in a README.md, like this:

  <!-- `bmdf seq 3` -->
  ```bash
  seq 3



  ```

  (Note how the command is `bash`-highlighted, and output lines are rendered as comments)

  Put a placeholder like this in your README.md:
    ````
    <!-- `bmdf seq 3` -->
    ````

  then [run `mdcmd`](#mdcmd) to update your README containing this embedded command block.


  `bmdff` (alias for `bmd -ff`) renders two code fences, one with the Bash command (syntax-highlighted appropriately), and a second (non-highlighted) block with the output, e.g.:

    ````
    <!-- `bmdff seq 5` -->
    ````

  becomes:

  <!-- `bmdff seq 5` -->
  ```bash
  seq 5
  ```
  ```
  1
  2
  3
  4
  5
  ```



  When a command's output is large, rendering it as a `<details><summary>` (with the output collapsed, by default) may be preferable.

  `bmdfff` (3 `f`s, alias for `bmd -fff`) transforms placeholders like this:

    ````
    <!-- `bmdfff seq 10` -->
    ````

  to:

  <!-- `bmdfff seq 10` -->
  <details><summary><code>seq 10</code></summary>

  ```
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  ```
  </details>



  ```bash

  mdcmd -i README.md

  mdcmd
  ```

  The placeholder block above will now contain `seq 3` and its output; that's how first block above is rendered!

  The full README.md block will now look like:
    ````
    <!-- `bmdf seq 3` -->
    ```bash
    seq 3
    
    
    
    ```
    ````

  and running `mdcmd` again will rewrite the same content.

  Note: `bmdf` (alias for `bmd -f`) is used because it wraps the output of whatever it's passed in a "Bash fence" block. You don't have to use it, but most commands will fail to output a Markdown "fence" block, and subsequent `mdcmd` invocations will fail to parse them.


  Put a block like this in your README.md:
  ````
  <!-- toc -->
  <!-- /toc -->
  ````

  Then put empty `<a>` tags next to the headings you want to include, e.g.:

   ```markdown
   
   ```

  (This allows for customizing and shortening the `id`s, as well as skipping sections)

  Then run:
  ```bash

  mktoc -i README.md

  mktoc
  ```

  And the `<!-- toc  -->` section will have a table of contents injected (like the one at the top of this file).



  <!-- `bmdf bmd` -->
  ```bash
  bmd





















  ```

  <!-- `bmdf -- mdcmd --help` -->
  ```bash
  mdcmd --help




















  ```

  <!-- `bmdf -- mktoc --help` -->
  ```bash
  mktoc --help





















  ```

  (these blocks are self-hosted, using `bmdf` and `mdcmd`; likewise [the table of contents up top](#toc), via `mktoc` 😎)


  - [runsascoded/juq]
  - [runsascoded/utz]
  - [runsascoded/dvc-utils]
  - [ryan-williams/git-helpers]
  - [ryan-williams/tdbs-dask]
  - [TileDB-Inc/scverse-ml-workshop-2024]

  [runsascoded/utz]: https://github.com/runsascoded/utz?tab=readme-ov-file#utz
  [TileDB-Inc/scverse-ml-workshop-2024]: https://github.com/TileDB-Inc/scverse-ml-workshop-2024?tab=readme-ov-file#training-models-on-atlas-scale-single-cell-datasets
  [ryan-williams/tdbs-dask]: https://github.com/ryan-williams/tdbs-dask?tab=readme-ov-file#tdbs-dask
  [ryan-williams/git-helpers]: https://github.com/ryan-williams/git-helpers?tab=readme-ov-file#git-helpers
  [runsascoded/dvc-utils]: https://github.com/runsascoded/dvc-utils
  [runsascoded/juq]: https://github.com/runsascoded/juq

  [bmdf]: https://pypi.org/project/bmdf/


pkgId: 7cc6d13e6934f992036b0306990b98805439da59c827834604b6502b0c0626b0
name: python-bmdrc
arch: src
version: 0.0.1.2
epoch: 0
release: 1
summary: A package for fitting benchmark dose curves to dichotomous data and light photomotor response data
url: https://github.com/PNNL-CompBio/bmdrc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmdrc-0.0.1.2-1.src.rpm
checksum_type: sha256
description:
  Python library for the calculation of **B**ench**M**ark **D**ose **R**esponse **C**urves (bmdrc)



  The bmdrc library was built to calculate benchmark dose (BMD) response curves for dichotomous (morphological) and light photomotor response datasets, where continuous variables are transformed to dichotomous as described in [Thomas et al 2019](https://www.sciencedirect.com/science/article/pii/S2468111318300732). Potential outputted files include a csv file of all final BMDs and their estimation errors, a csv file of model fits (AIC) for each endpoint, and an html report containing information on how much data was filtered and why, as well as interactive response curve plots. Users may specify their outputs of interest.

  ![General bmdrc inputs and outputs](./bmdrc.png)

  1. *Input Data Module:* Import data into the python library

  2. *Pre-Processing Module:* Combine and remove endpoints as needed

  3. *Filtering Modules:* Apply the EPA recommendations for filtering

  4. *Model Fitting Modules:* Fit EPA-recommended models to data

  5. *Output Modules:* Select tables to output as csvs. View plots in a HTML report.



  First, install the package from pip using:

  `pip install bmdrc`

  Or from github using:

  `pip install git+https://github.com/PNNL-CompBio/bmdrc`




  An example vignette for the dichotomous (binary) data is located [here](./vignettes/Binary%20Class%20Example.ipynb) and an example vignette for the light photomotor response data (continuous converted to dichotomous) is located [here](./vignettes/LPR%20Class%20Example.ipynb).


  Example data for dichotomous and light photomotor response data can be found [here](./data/).


  A sample for the generated report for dichotomous (binary) data can be found [here](https://github.com/PNNL-CompBio/bmdrc/blob/main/example_report/binary_class/Benchmark%20Dose%20Curves.md)

  A sample for the generated report for light photomotor response data can be found [here](https://github.com/PNNL-CompBio/bmdrc/blob/main/example_report/lpr_class/Benchmark%20Dose%20Curves.md)



  | Name                      | Stmts  | Miss | Cover |
  |---------------------------|--------|------|-------|
  | bmdrc/BinaryClass.py      |  138   |   0  | 100%  |
  | bmdrc/LPRClass.py         |  211   |   0  | 100%  |
  | bmdrc/filtering.py        |  146   |   0  | 100%  |
  | bmdrc/model_fitting.py    |  687   |   5  |  99%  |
  | bmdrc/output_modules.py   |  125   |   2  |  98%  |
  | bmdrc/preprocessing.py    |   59   |   0  | 100%  |
  | **TOTAL**                 | **1366**|**7**|**99%**|


pkgId: 3cc32b83a34dcf3e88acf72ea33a7a71cb33653501ef69aba7e21076bc47b3d5
name: python-bme
arch: src
version: 1.4.4
epoch: 0
release: 1
url: https://github.com/jiri-otoupal/bme
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bme-1.4.4-1.src.rpm
checksum_type: sha256
summary:
  Never use notepads or history for searching for your past commands. With BME you can bookmark your commands, search in your bookmarked commands and execute them with edit possibility before execution.

description:
  (Bookmark my Executions/Commands)

  Never use notepads or history for searching for your past commands. With BME you can bookmark your commands, search in your bookmarked commands and
  execute them with edit possibility before execution.

  [![image](https://img.shields.io/pypi/v/bme.svg)](https://pypi.org/project/bme/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bme)](https://pypi.org/project/bme/)
  [![Downloads](https://pepy.tech/badge/bme)](https://pepy.tech/project/bme)





  No specific requirements here, whatever runs Python





  * 3.7+





  On most MacOS machines there is `pip3` instead of `pip` **use pip3 for install**

  Install and update using [pip](https://pip.pypa.io/en/stable/quickstart/):

  ```bash
  pip install bme

  or

  pip3 install bme
  ```







  _(Quotas can be used)_

  ```
  bme add <your command>
  ```



  _(Quotas can be used)_

  ```
  bme rm <your command>
  ```



  _(Quotas can be used)_

  ```
  bme list <searched>
  ```

  * searched is optional, only if you want to list specific commands
  * Regex, match case and full word flags are supported



  Basic search `bme run <searched>`

  Regex search `bme run <searched> -r <my-regex*>`



  You can format command from bookmark with python formatting as such

  * Use {} to be placeholder for your tuple arguments
  * Use {name} to be placeholder with key name for your dictionary arguments

  **Mixing tuple and dict arguments is not supported!**

  Example:

  Tuple:

  ```
  bme add echo "Hello {} !"
  bme run ec Jiri
  ```

  Dictionary arguments:

  ```
  bme add echo "Hello {name} from {location}"
  bme run ec name=Jiri location=Prague
  ```

  **or**

  ```
  bme run ec name=\"Jiri\" location=\"Prague\"
  ```



  `"-e" or "--edit"` for editing command before execution

  `"-r <your-regex>" or "--regex <your-regex>"` for full word search only

  `"-f" or "--full-word"` for full word search only

  `"-m" or "--match-case"` for search with matching case

  _(Quotas can be used)_

  ```
  bme run <your command>
  ```



  Sequences are like scripts, except you don't have to search for location and manage them with different `.bashrc` or different OS specific files.
  Also thanks to this, you don't have to add them to PATH.

  BME will take care of storing your sequences in your `~/.bme` folder and will help you to search in them.
  These sequences work from everywhere and execution is always in your current working directory.



  **Create Sequence**

  `bme seq create {name}`

  Example:

  `bme seq create my_sequence`

  **Remove Sequence**

  `bme seq rm {name}`

  Example

  `bme seq rm my_sequence`

  **Edit Sequence**

  `bme seq edit`

  This will display location of json with sequences

  **Add Command to Sequence**

  This will add command to sequence with use of variadic arguments

      bme seq add {sequence_name} {command...}

  Example:

      bme seq add my_sequence ssh jiri@192.168.1.0

  **Pop Command from Sequence**

  This will pop command from sequence with use of variadic arguments

      bme seq pop {sequence_name} {command...}

  Example:

      bme seq pop my_sequence ssh jiri@192.168.1.0

  **Sequence Run**

  Runs supplied sequence, and will do search for you if not found

      bme sequence run {sequence_name}

  Sequence does support formatting of dynamic arguments same way as bookmarks
  these arguments will be passed to every command for formatting

  Example:

      bme sequence run my_sequence John

  or

      bme sequence run my_sequence name=John

  **Sequence Watch (!BETA!)**

  Launches sequence on file modify

      bme sequence watch {sequence_name} {file_path}

  **List Sequence**

  This will list commands and sequences, if argument is used search in text is applied to results

  Optional flags:

      "-r <your-regex>" or "--regex <your-regex>"` for full word search only
      "-f" or "--full-word" for full word search only
      "-m" or "--match-case" for search with matching case

  Example Data:

      In sequence DB there is:
       'ssh jiri@192.168.1.0' command
       'ssh jiri@192.168.1.55' command
       'scp jiri@192.168.1.55' command

  Command `bme sequence list` will list all the sequences and their commands

  Specific listing format:

      bme sequence list <optional commands that match this to list>

  Example:

      bme sequence list ssh

  Output:

  ```
  'ssh jiri@192.168.1.0' command
  'ssh jiri@192.168.1.55' command
  ```

  <hr>
  Did I made your life less painful ?
  <br>
  <br>
  Support my coffee addiction ;)
  <br>
  <a href="https://www.buymeacoffee.com/jiriotoupal" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy me a Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>


pkgId: ee96a60e821b2954975ddf205ce6751e3f67f220f8a2bf7498f0917273385537
name: python-bme680
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python library for the BME680 temperature, humidity and gas sensor
description:
  * Repackage to hatch/pyproject.toml
  * Drop Python 2.7 support
  * Switch from smbu2 to smbus2

url: https://www.pimoroni.com
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bme680-2.0.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018 Pimoroni Ltd  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: 3e5b5f173b41e25e2c447160f0656da14e795bdfc383808bb17b8690dfe43c7e
name: python-bmicro
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: GUI for Brillouin evaluation
url: https://github.com/BrillouinMicroscopy/BMicro
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmicro-0.10.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI Version| |Build Status Unix| |Coverage Status| |Docs Status|
  This is a Python library for the post-measurement analysis of
  Brillouin microscopy data.


pkgId: 96c58fd25c0a981888bf9cf4b2aed2e33518e1119648e0775421cbb34187c22c
name: python-bmnspeechlib
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A fork of speechlib with customizations for our team
url: https://pypi.org/project/bmnspeechlib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmnspeechlib-0.1.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Navod Peiris  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: 71a159ad47f44bc2ca645f0c53ae9d74347a47e92260edb2be2e9a326775cd98
name: python-bmsdna-lakeapi
arch: src
version: 0.21.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bmsdna-lakeapi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmsdna-lakeapi-0.21.8-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <img src="https://raw.githubusercontent.com/bmsuisse/lakeapi/main/assets/LakeAPI.drawio.png">
    <br>
  </h1>

  [![tests](https://github.com/bmsuisse/lakeapi/actions/workflows/python-test.yml/badge.svg?branch=main)](https://github.com/bmsuisse/lakeapi/actions/workflows/python-test.yml)

  A `FastAPI` plugin that allows you to expose your data lake as an API, allowing several output formats such as Parquet, Csv, Json, Excel, ...

  The LakeAPI also includes a minimal security layer for convenience (Basic Auth), but you can also bring your own.

  Unlike [roapi](https://github.com/roapi/roapi), we intentionally do not expose most SQL by default, but limit the possible queries with a config. This makes it easy for you to control what happens to your data. If you want the SQL endpoint, you can enable it. And because we built LakeAPI on the shoulders of giants like FastAPI. A lot of things like documentation and authentication are built in and we don't have to reinvent the wheel.

  To run the application with the default config, just do it:

  ```python
  app = FastAPI()
  bmsdna.lakeapi.init_lakeapi(app)
  ```

  To adjust the config, you can do like this:

  ```python
  import dataclasses
  import bmsdna.lakeapi

  def_cfg = bmsdna.lakeapi.get_default_config() # Get default startup config
  cfg = dataclasses.replace(def_cfg, enable_sql_endpoint=True, data_path="tests/data") # Use dataclasses.replace to set the properties you want
  sti = bmsdna.lakeapi.init_lakeapi(app, cfg, "config_test.yml") # Enable it. The first parameter is the FastAPI instance, the 2nd one is the basic config and the third one the config of the tables
  ```



  [![PyPI version](https://badge.fury.io/py/bmsdna-lakeapi.svg)](https://pypi.org/project/bmsdna-lakeapi/)

  Pypi Package `bmsdna-lakeapi` can be installed like any python package : `pip install bmsdna-lakeapi`



  Based on a `YAML` configuration and the data source, LakeAPI will automatically generate GET and/or POST endpoints.
  Calling the endpoint turns the query into an SQL statement that can be executed with the engine of your choice (duckdb or polars).
  The result is then seralised into the requested format (Json, CSV, Arrow etc).

  This makes it super easy to distribute your data lake data to other systems. We use it internally to feed data to MS SQL Server, SQLite, Streamlit and Web Apps. You can host it wherever you want, we use Azure Websites which works fine even for very large data amounts.



  Of course everything works with `OpenAPI` and `FastAPI`. This means you can add other FastAPI routes, you can use the /docs and /redoc endpoints.

  So everything will be fully documented automatically, which is really cool. 🔥🔥



  `DuckDB` is the default query engine. `Polars` is also supported, but lack some features. The query engine can be specified at the route level and at the query level with the hidden parameter $engine="duckdb|polars". If you want polars, add the required extra.

  At the moment, DuckDB seems to have an advantage and performs the best. Also features like full text search are only available with `DuckDB`.



  Deltalake is supported WITH Column Mapping, thanks to [deltalake2db](https://github.com/bmsuisse/deltalake2db) in Polars and DuckDB. Deletion Vectors are not supported yet.



  By Default, Basic Authentication is enabled. To add a user, simply run `add_lakeapi_user YOURUSERNAME --yaml-file config.yml`. This will add the user to your config yaml (argon2 encrypted).
  The generated Password is printed. If you do not want this logic, you can overwrite the username_retriver of the Default Config



  If you just want to run this thing, you can run it with a webserver:

  Uvicorn: `uvicorn bmsdna.lakeapi.standalone:app --host 0.0.0.0 --port 8080`

  Gunicorn: `gunicorn bmsdna.lakeapi.standalone:app --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:80`

  Of course you need to adjust your http options as needed. Also, you need to `pip install` uvicorn/gunicorn

  You can still use environment variables for configuration



  - CONFIG_PATH: The path of the config file, defaults to `config.yml`. If you want to split the config, you can specify a folder, too
  - DATA_PATH: The path of the data files, defaults to `data`. Paths in `config.yml` are relative to DATA_PATH
  - ENABLE_SQL_ENDPOINT: Set this to 1 to enable the SQL Endpoint



  The application by default relies on a Config file beeing present at the root of your project that's call `config.yml`.

  The config file looks something like this, see also [our test yaml](https://raw.githubusercontent.com/bmsuisse/lakeapi/dev/config_test.yml):

  ```yaml
  tables:
    - name: fruits
      tag: test
      version: 1
      api_method:
        - get
        - post
      params:
        - name: cars
          operators:
            - "="
            - in
        - name: fruits
          operators:
            - "="
            - in
      datasource:
        uri: delta/fruits
        file_type: delta

    - name: fruits_partition
      tag: test
      version: 1
      api_method:
        - get
        - post
      params:
        - name: cars
          operators:
            - "="
            - in
        - name: fruits
          operators:
            - "="
            - in
        - name: pk
          combi:
            - fruits
            - cars
        - name: combi
          combi:
            - fruits
            - cars
      datasource:
        uri: delta/fruits_partition
        file_type: delta
        select:
          - name: A
          - name: fruits
          - name: B
          - name: cars

    - name: fake_delta
      tag: test
      version: 1
      allow_get_all_pages: true
      api_method:
        - get
        - post
      params:
        - name: name
          operators:
            - "="
        - name: name1
          operators:
            - "="
      datasource:
        uri: delta/fake
        file_type: delta

    
    - name: fruits_duck
      tag: test
      version: 1
      api_method:
        - get
        - post
      datasource:
        uri: duckdb/fruits.db
        file_type: duckdb
        table_name: fruits
      params:
        - name: fruits
          operators:
            - "="
            - in
        - name: cars
          operators:
            - "="
            - "in"

    - name: fake_delta_partition
      tag: test
      version: 1
      allow_get_all_pages: true
      api_method:
        - get
        - post
      params:
        - name: name
          operators:
            - "="
        - name: name1
          operators:
            - "="
      datasource:
        uri: delta/fake
        file_type: delta

    - name: "*" # We're lazy and want to expose all in that folder. Name MUST be * and nothing else
      tag: startest
      version: 1
      api_method:
        - post
      datasource:
        uri: startest/* # Uri MUST end with /*
        file_type: delta

    - name: fruits # But we want to overwrite this one
      tag: startest
      version: 1
      api_method:
        - get
      datasource:
        uri: startest/fruits/${IN_URI_YOU_CAN_HAVE_ENVIRONMENT_VARIABLES}
        file_type: delta

    - name: mssql_department
      tag: mssql
      api_method: get
      engine: odbc #requires the odbc extra
      datasource:
        uri: DRIVER={ODBC Driver 17 for SQL Server};SERVER=127.0.0.1,1439;ENCRYPT=yes;TrustServerCertificate=Yes;UID=sa;PWD=${MY_SQL_PWD};Database=AdventureWorks
        table_name: "HumanResources.Department"
      params:
        - GroupName
  ```



  To use partitions, you can either

  - Partition by a column that you filter on. Obviously
  - partition on a special column called `columnname_md5_prefix_2`, which means that you're partitioning on the first two characters of your hex-coded md5 hash.
    of the hexadecimal md5 hash. If you now filter by `columnname`, this will greatly reduce the number of files you search for. The number of characters used is up to you, we found two to be useful
  - partition on a special column called `columnname_md5_mod_NRPARTITIONS`, where your partition value is `str(int(hashlib.md5(COLUMNNAME).hexdigest(), 16) % NRPARTITIONS)`. This might look a bit complicated, but it's not that hard :) You're just doing a modulo on your md5 hash, which allows you to
    which allows you to set the exact number of partitions. Filtering is still done correctly on `columnname`.

  Why partition by MD5 hash? Imagine you have a product id where most id's start with a 1 and some newer ones start with a 2. Most of the data will be in the first partition. If you use an MD5 hash, the data will be spread evenly across the partitions.

  With this hack you can get sub-second results on very large data. 🚀🚀

  You need to use `deltalake` to use partitions, and you only need str partition columns for now.

  [Z-ordering](https://docs.delta.io/latest/optimizations-oss.html#z-ordering-multi-dimensional-clustering) can also help a lot :).



  - Built-in paging, you can use limit/offset to control what you get
  - Full-text search using DuckDB's full-text search feature
  - jsonify_complex parameter to convert structs/lists to json, the client cannot handle structs/lists
  - Metadata endpoints to retrieve data types, string lengths and more
  - Easily expose entire folders by using a "\*" wildcard in both the name and the datasource.uri config, see example in the config above
  - Config in delta table as json, by using the lakeapi.config Table property. Example in the tests. This allows to have the config for the lakeapi along with your data
  - Good test coverage



  If you want to use ODBC , install the required extra (named `odbc`).

  ODBC Tables cannot be queried through the sql endpoint for now because of Security Implications.
  We might allow this later if needed via explicit flag.

  ODBC is tested against MS SQL Server using ODBC Driver 17 for MS SQL Server

  To use Sqlite, you will need to install `adbc_driver_sqlite` yourself (`pip install adbc_driver_sqlite`).



  Azure Support is tested and supported. S3/GCP could work in theory but is not tested.
  Supported configs are taken from object_store create and fsspec:

  - https://docs.rs/object_store/latest/object_store/azure/enum.AzureConfigKey.html#variants
  - https://github.com/fsspec/adlfs#setting-credentials

  Supported settings are only those which are supported by BOTH projects. In practice you can currently use:

  - account_name
  - account_key
  - use_emulator (we add that one for fsspec)
  - anon (fsspec/adlfs for anonymous). Adlfs default this to true, we default to false. Set to true if you really want to.

  If you want to use [Azure Default Credential](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.defaultazurecredential?view=azure-python), just specify account_name without any further option.



  - [lakeapi2sql](https://github.com/bmsuisse/lakeapi2sql) Allows you to read from lake api and write to MS SQL Server



  Please note that this is a work in progress, changes will be made and things may break. Especially at this early stage.
  We recommend only using the export from `bmsdna.lakeapi` for now and not to use the submodules.



  - You can currently only serve local files. We might add support for `fsspec` later on. You can still mount your data if you use Linux, which is what we do in production



  Feel free to contribute, report bugs or request enhancements.


pkgId: b939f8cd6d0523970f0802c59887c3cf7dbfb44465cd5c2e3613db70c6ad84e0
name: python-bmstu-schedule
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: BMSTU EU Schedule iCal parser
url: https://github.com/BMSTU-Schedule/bmstu-schedule-parser
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmstu-schedule-1.5.4-1.src.rpm
checksum_type: sha256
description:
  [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)



  ```bash
  pip3 install bmstu-schedule
  ```
  **Make sure that everything is ok with your Python bin folder and your PATH**


  ```bash
  bmstu-schedule иу6-54
  ```
  *If you get the "нет расписания" file, try to specify the type of group, like:
  "иу6-51Б" or "иу6-51А"*
  ![](img/step1.png)

  ![](img/step2.png)

  ![](img/step3.png)


pkgId: 38b155cf82b96bd27bbc8549050856a95a6362058d3d8fa99fdf5e35e689e0ab
name: python-bmt
arch: src
version: 1.4.4
epoch: 0
release: 1
summary: Biolink Model Toolkit: A Python API for working with the Biolink Model
url: https://github.com/biolink/biolink-model-toolkit
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmt-1.4.4-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/badge/python-3.7+-blue.svg)]()
  [![PyPI](https://img.shields.io/pypi/v/bmt)](https://img.shields.io/pypi/v/bmt)



  Biolink Model Toolkit (BMT): A Python API for working with the [Biolink Model](https://github.com/biolink/biolink-model).

  BMT provides utility functions to look up Biolink Model for classes, relations, and properties based on Biolink CURIEs
  or external CURIEs that have been mapped to Biolink Model.

  > Note: Each release of BMT is pinned to a specific version of the Biolink Model to ensure consistency.



  BMT provides convenience methods to operate on the Biolink Model.

  Using this toolkit you can,
  - Get Biolink Model elements corresponding to a given Biolink class or slot name
  - Get Biolink Model elements corresponding to a given external CURIE/IRI
  - Get ancestors for a given Biolink Model element
  - Get descendants for a given Biolink Model element
  - Get parent for a given Biolink Model element
  - Get children for a given Biolink Model element
  - Check whether a given Biolink Model element is part of a specified subset


pkgId: 972fc6f0611eeff94a15ed48f0ecff72f9c74478f8b42d0e7cb751119e02a408
name: python-bmtool
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: BMTool
url: https://github.com/cyneuro/bmtool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmtool-0.5.9-1.src.rpm
checksum_type: sha256
description:
  A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.

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


  - [Getting Started](#Getting-Started)
  - [CLI](#CLI)
  - [Single Cell](#Single-Cell-Module)
  - [Connectors](#Connectors-Module)
  - [Bmplot](#bmplot-Module)
  - [Graphs](#graphs-module)



  **Installation**
  ```bash
  pip install bmtool
  ```
  For developers who will be pulling down additional updates to this repository regularly use the following instead.
  ```bash
  git clone https://github.com/cyneuro/bmtool.git
  cd bmtool
  python setup.py develop
  ```
  Then download updates (from this directory) with
  ```bash
  git pull
  ```



  ```bash
  > cd your_bmtk_model_directory
  > bmtool
  Usage: bmtool [OPTIONS] COMMAND [ARGS]...

  Options:
    --verbose  Verbose printing
    --help     Show this message and exit.

  Commands:
    debug
    plot
    util

  >
  > bmtool plot
  Usage: bmtool plot [OPTIONS] COMMAND [ARGS]...

  Options:
    --config PATH  Configuration file to use, default: "simulation_config.json"
    --no-display   When set there will be no plot displayed, useful for saving
                   plots
    --help         Show this message and exit.

  Commands:
    connection  Display information related to neuron connections
    positions   Plot cell positions for a given set of populations
    raster      Plot the spike raster for a given population
    report      Plot the specified report using BMTK's default report plotter
  >
  ```


  - [Passive properties](#passive-properties)
  - [Current injection](#current-clamp)
  - [FI curve](#fi-curve)
  - [ZAP](#zap)
  - [Tuner](#single-cell-tuning)
  - [VHalf Segregation](#vhalf-segregation-module)





  ```python
  from bmtool.singlecell import Profiler
  profiler = Profiler(template_dir='templates', mechanism_dir = 'mechanisms', dt=0.1)
  ```




  ```python
  from bmtool.singlecell import load_allen_database_cells
  cell = load_allen_database_cells(path_to_SWC_file,path_to_json_file)
  ```





  ```python
  from bmtool.singlecell import Passive,run_and_plot
  import matplotlib.pyplot as plt
  sim = Passive('Cell_Cf', inj_amp=-100., inj_delay=1500., inj_dur=1000., tstop=2500., method='exp2')
  title = 'Passive Cell Current Injection'
  xlabel = 'Time (ms)'
  ylabel = 'Membrane Potential (mV)'
  X, Y = run_and_plot(sim, title, xlabel, ylabel, plot_injection_only=True)
  plt.gca().plot(*sim.double_exponential_fit(), 'r:', label='double exponential fit')
  plt.legend()
  plt.show()
  ```

      Injection location: Cell_Cf[0].soma[0](0.5)
      Recording: Cell_Cf[0].soma[0](0.5)._ref_v
      Running simulation for passive properties...

      V Rest: -70.21 (mV)
      Resistance: 128.67 (MOhms)
      Membrane time constant: 55.29 (ms)

      V_rest Calculation: Voltage taken at time 1500.0 (ms) is
      -70.21 (mV)

      R_in Calculation: dV/dI = (v_final-v_rest)/(i_final-i_start)
      (-83.08 - (-70.21)) / (-0.1 - 0)
      12.87 (mV) / 0.1 (nA) = 128.67 (MOhms)

      Tau Calculation: Fit a double exponential curve to the membrane potential response
      f(t) = a0 + a1*exp(-t/tau1) + a2*exp(-t/tau2)
      Constained by initial value: f(0) = a0 + a1 + a2 = v_rest
      Fit parameters: (a0, a1, a2, tau1, tau2) = (-83.06, -3306.48, 3319.33, 55.29, 55.15)
      Membrane time constant is determined from the slowest exponential term: 55.29 (ms)

      Sag potential: v_sag = v_peak - v_final = -0.66 (mV)
      Normalized sag potential: v_sag / (v_peak - v_rest) = 0.049





  ![png](readme_figures/output_8_1.png)







  ```python
  from bmtool.singlecell import CurrentClamp
  sim = CurrentClamp('Cell_Cf', inj_amp=350., inj_delay=1500., inj_dur=1000., tstop=3000., threshold=-15.)
  X, Y = run_and_plot(sim, title='Current Injection', xlabel='Time (ms)',
                      ylabel='Membrane Potential (mV)', plot_injection_only=True)
  plt.show()
  ```

      Injection location: Cell_Cf[1].soma[0](0.5)
      Recording: Cell_Cf[1].soma[0](0.5)._ref_v
      Current clamp simulation running...

      Number of spikes: 19





  ![png](readme_figures/output_10_1.png)







  ```python
  from bmtool.singlecell import FI
  sim = FI('Cell_Cf', i_start=0., i_stop=1000., i_increment=50., tstart=1500.,threshold=-15.)
  X, Y = run_and_plot(sim, title='FI Curve', xlabel='Injection (nA)', ylabel='# Spikes')
  plt.show()
  ```

      Injection location: Cell_Cf[21].soma[0](0.5)
      Recording: Cell_Cf[21].soma[0](0.5)._ref_v
      Running simulations for FI curve...

      Results
      Injection (nA): 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95
      Number of spikes: 0, 1, 10, 12, 15, 16, 17, 19, 20, 20, 21, 21, 22, 23, 23, 24, 25, 25, 26, 27





  ![png](readme_figures/output_12_1.png)







  ```python
  from bmtool.singlecell import ZAP
  sim = ZAP('Cell_Cf')
  X, Y = run_and_plot(sim)
  plt.show()
  ```

      Injection location: Cell_Cf[22].soma[0](0.5)
      Recording: Cell_Cf[22].soma[0](0.5)._ref_v
      ZAP current simulation running...

      Chirp current injection with frequency changing from 0 to 15 Hz over 15 seconds
      Impedance is calculated as the ratio of FFT amplitude of membrane voltage to FFT amplitude of chirp current





  ![png](readme_figures/output_14_1.png)






  ```bash
  bmtool util cell tune --builder
  ```


  ```bash
  bmtool util cell --template TemplateFile.hoc --mod-folder ./ tune --builder
  ```
  ![bmtool](./figures/figure2.png "Tuning Figure")








  ```bash
  > bmtool util cell vhseg --help

  Usage: bmtool util cell vhseg [OPTIONS]

    Alturki et al. (2016) V1/2 Automated Segregation Interface, simplify
    tuning by separating channel activation

  Options:
    --title TEXT
    --tstop INTEGER
    --outhoc TEXT         Specify the file you want the modified cell template
                          written to
    --outfolder TEXT      Specify the directory you want the modified cell
                          template and mod files written to (default: _seg)
    --outappend           Append out instead of overwriting (default: False)
    --debug               Print all debug statements
    --fminpa INTEGER      Starting FI Curve amps (default: 0)
    --fmaxpa INTEGER      Ending FI Curve amps (default: 1000)
    --fincrement INTEGER  Increment the FI Curve amps by supplied pA (default:
                          100)
    --infvars TEXT        Specify the inf variables to plot, skips the wizard.
                          (Comma separated, eg: inf_mech,minf_mech2,ninf_mech2)
    --segvars TEXT        Specify the segregation variables to globally set,
                          skips the wizard. (Comma separated, eg:
                          mseg_mech,nseg_mech2)
    --eleak TEXT          Specify the eleak var manually
    --gleak TEXT          Specify the gleak var manually
    --othersec TEXT       Specify other sections that a window should be
                          generated for (Comma separated, eg: dend[0],dend[1])
    --help                Show this message and exit.

  ```





  ```bash
  > bmtool util cell vhseg

  ? Select a cell:  CA3PyramidalCell
  Using section dend[0]
  ? Show other sections? (default: No)  Yes
  ? Select other sections (space bar to select):  done (2 selections)
  ? Select inf variables to plot (space bar to select):   done (5 selections)
  ? Select segregation variables [OR VARIABLES YOU WANT TO CHANGE ON ALL SEGMENTS at the same time] (space bar to select):  done (2 selections)
  ```



  ```bash
  bmtool util cell --template CA3PyramidalCell vhseg --othersec dend[0],dend[1] --infvars inf_im --segvars gbar_im --gleak gl_ichan2CA3 --eleak el_ichan2CA3
  ```

  Example:

  ![bmtool](./figures/figure4.png "Seg Figure")


  ``` bash
  bmtool util cell --hoc cell_template.hoc vhsegbuild --build
  bmtool util cell --hoc segmented_template.hoc vhsegbuild
  ```
  ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cell-hco)


  - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
  - [ReciprocalConnector](#recipical-connector---buiilding-connections-in-bmtk-network-model-with-reciprocal-probability-within-a-single-population-or-between-two-populations)
  - [CorrelatedGapJunction](#correlatedgapjunction)
  - [OneToOneSequentialConnector](#onetoonesequentialconnector)




  ```python
  from bmtk.builder import NetworkBuilder
  net = NetworkBuilder('example_net')
  net.add_nodes(N=100, pop_name='PopA',model_type = 'biophysical')
  net.add_nodes(N=100, pop_name='PopB',model_type = 'biophysical')

  background = NetworkBuilder('background')
  background.add_nodes(N=300,pop_name='tON',potential='exc',model_type='virtual')
  ```


  ```python
  from bmtool.connectors  import UnidirectionConnector
  connector = UnidirectionConnector(p=0.15, n_syn=1)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors  import ReciprocalConnector
  connector = ReciprocalConnector(p0=0.15, pr=0.06767705087, n_syn0=1, n_syn1=1,estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors import ReciprocalConnector, CorrelatedGapJunction
  connector = ReciprocalConnector(p0=0.15, pr=0.06, n_syn0=1, n_syn1=1, estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  net.add_edges(**connector.edge_params())
  gap_junc = CorrelatedGapJunction(p_non=0.1228,p_uni=0.56,p_rec=1,connector=connector)
  gap_junc.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  conn = net.add_edges(is_gap_junction=True, syn_weight=0.0000495, target_sections=None,afferent_section_id=0, afferent_section_pos=0.5,
  **gap_junc.edge_params())
  ```


  ```python
  from bmtool.connectors  import OneToOneSequentialConnector
  connector = OneToOneSequentialConnector()
  connector.setup_nodes(source=background.nodes(), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  connector.setup_nodes(target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```


  - [Total connections](#Total-connection-plot)
  - [Percent connections](#Percent-connection-plot)
  - [Convergence connnections](#convergence-plot)
  - [Divergence connections](#divergence-plot)
  - [Gap Junction connections](#gap-junction-plot)
  - [connection histogram](#connection-histogram)
  - [probability connection](#probability-of-connection-plot)
  - [3D location](#3d-position-plot)
  - [3D rotation](#cell-rotations)
  - [Plot Connection Diagram](#plot-connection-diagram)





  ```python
  from bmtool import bmplot
  bmplot.total_connection_matrix(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True,include_gap=False)
  ```



  ![png](readme_figures/output_19_0.png)







  ```python
  bmplot.percent_connection_matrix(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True,method='total',include_gap=False)
  ```



  ![png](readme_figures/output_21_0.png)







  ```python
  bmplot.convergence_connection_matrix(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True,include_gap=False,method='mean+std')
  ```



  ![png](readme_figures/output_23_0.png)







  ```python
  bmplot.divergence_connection_matrix(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True,include_gap=False,method='mean+std')
  ```



  ![png](readme_figures/output_25_0.png)





  ```python
  bmplot.gap_junction_matrix(config='config.json',sources='LA',targets='LA',sids='pop_name',tids='pop_name',no_prepend_pop=True,type='percent')
  ```



  ![png](output_gap.png)






  ```python
  bmplot.connection_histogram(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',source_cell='PV',target_cell='PV',include_gap=False)
  ```



  ![png](readme_figures/output_27_0.png)







  ```python
  bmplot.probability_connection_matrix(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True,line_plot=True)
  ```



  ![png](readme_figures/output_29_0.png)





  ![png](readme_figures/output_29_1.png)







  ```python
  bmplot.plot_3d_positions(config='config.json',populations_list='LA',group_by='pop_name',save_file=False)
  ```



  ![png](readme_figures/output_31_0.png)







  ```python
  bmplot.cell_rotation_3d(config='config2.json',populations_list='all',group_by='pop_name',save_file=False,quiver_length=20,arrow_length_ratio=0.25,max_cells=100)
  ```



  ![png](readme_figures/output_33_0.png)






  ```python
  bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True)
  ```



  ![png](readme_figures/output_35_0.png)






  ```python
  from bmtool import bmplot
  bmplot.plot_basic_cell_info(config_file='config.json')
  ```

      Network and node info:
      LA:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>model_template</th>
        <th>morphology</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>PNa</td>
        <td>biophysical</td>
        <td>hoc:Cell_Af</td>
        <td>blank.swc</td>
        <td>800</td>
      </tr>
      <tr>
        <th>1</th>
        <td>101</td>
        <td>PNc</td>
        <td>biophysical</td>
        <td>hoc:Cell_Cf</td>
        <td>blank.swc</td>
        <td>800</td>
      </tr>
      <tr>
        <th>2</th>
        <td>102</td>
        <td>PV</td>
        <td>biophysical</td>
        <td>hoc:InterneuronCellf</td>
        <td>blank.swc</td>
        <td>240</td>
      </tr>
      <tr>
        <th>3</th>
        <td>103</td>
        <td>SOM</td>
        <td>biophysical</td>
        <td>hoc:LTS_Cell</td>
        <td>blank.swc</td>
        <td>160</td>
      </tr>
    </tbody>
  </table>


      thalamus_pyr:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>pyr_inp</td>
        <td>virtual</td>
        <td>1600</td>
      </tr>
    </tbody>
  </table>


      thalamus_pv:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>pv_inp</td>
        <td>virtual</td>
        <td>240</td>
      </tr>
    </tbody>
  </table>


      thalamus_som:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>som_inp</td>
        <td>virtual</td>
        <td>160</td>
      </tr>
    </tbody>
  </table>


      tone:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>tone</td>
        <td>virtual</td>
        <td>1840</td>
      </tr>
    </tbody>
  </table>


      shock:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>shock</td>
        <td>virtual</td>
        <td>400</td>
      </tr>
    </tbody>
  </table>


      shell:



  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>node_type</th>
        <th>pop_name</th>
        <th>model_type</th>
        <th>count</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>100</td>
        <td>PNa</td>
        <td>virtual</td>
        <td>3975</td>
      </tr>
      <tr>
        <th>1</th>
        <td>101</td>
        <td>PNc</td>
        <td>virtual</td>
        <td>3975</td>
      </tr>
      <tr>
        <th>2</th>
        <td>102</td>
        <td>PV</td>
        <td>virtual</td>
        <td>1680</td>
      </tr>
      <tr>
        <th>3</th>
        <td>103</td>
        <td>SOM</td>
        <td>virtual</td>
        <td>1120</td>
      </tr>
    </tbody>
  </table>





      'LA'

  - [Generate graph](#generate-graph)
  - [Plot Graph](#plot-graph)
  - [Connectioon table](#generate-graph-connection-table)




  ```python
  from bmtool import graphs
  import networkx as nx

  Graph = graphs.generate_graph(config='config.json',source='LA',target='LA')
  print("Number of nodes:", Graph.number_of_nodes())
  print("Number of edges:", Graph.number_of_edges())
  print("Node labels:", set(nx.get_node_attributes(Graph, 'label').values()))
  ```

      Number of nodes: 2000
      Number of edges: 84235
      Node labels: {'SOM', 'PNc', 'PNa', 'PV'}






  ```python
  graphs.plot_graph(Graph)
  ```







  ```python
  import pandas as pd
  graphs.export_node_connections_to_csv(Graph, 'node_connections.csv')
  df = pd.read_csv('node_connections.csv')
  df.head()
  ```




  <div>
  <style scoped>
      .dataframe tbody tr th:only-of-type {
          vertical-align: middle;
      }

      .dataframe tbody tr th {
          vertical-align: top;
      }

      .dataframe thead th {
          text-align: right;
      }
  </style>
  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>Unnamed: 0</th>
        <th>Node Label</th>
        <th>PNc Connections</th>
        <th>PV Connections</th>
        <th>SOM Connections</th>
        <th>PNa Connections</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>0</td>
        <td>PNa</td>
        <td>15</td>
        <td>11</td>
        <td>9</td>
        <td>6</td>
      </tr>
      <tr>
        <th>1</th>
        <td>1</td>
        <td>PNa</td>
        <td>24</td>
        <td>25</td>
        <td>6</td>
        <td>21</td>
      </tr>
      <tr>
        <th>2</th>
        <td>2</td>
        <td>PNa</td>
        <td>27</td>
        <td>28</td>
        <td>12</td>
        <td>25</td>
      </tr>
      <tr>
        <th>3</th>
        <td>3</td>
        <td>PNa</td>
        <td>19</td>
        <td>27</td>
        <td>15</td>
        <td>35</td>
      </tr>
      <tr>
        <th>4</th>
        <td>4</td>
        <td>PNa</td>
        <td>25</td>
        <td>11</td>
        <td>8</td>
        <td>16</td>
      </tr>
    </tbody>
  </table>
  </div>


pkgId: 95a33da0f09198d15e0cea816d65786c48a346bd5f9ee2c606f7548e86226e50
name: python-bmtool
arch: src
version: 0.5.9.8
epoch: 0
release: 1
summary: BMTool
url: https://github.com/cyneuro/bmtool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmtool-0.5.9.8-1.src.rpm
checksum_type: sha256
description:
  A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.

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


  - [Getting Started](#getting-started)
  - [CLI](#cli)
  - [Single Cell](#single-cell-module)
  - [Synapses](#synapses-module)
  - [Connectors](#connectors-module)
  - [Bmplot](#bmplot-module)
  - [Graphs](#graphs-module)



  **Installation**
  ```bash
  pip install bmtool
  ```
  For developers who will be pulling down additional updates to this repository regularly use the following instead.
  ```bash
  git clone https://github.com/cyneuro/bmtool.git
  cd bmtool
  python setup.py develop
  ```
  Then download updates (from this directory) with
  ```bash
  git pull
  ```



  ```bash
  > cd your_bmtk_model_directory
  > bmtool
  Usage: bmtool [OPTIONS] COMMAND [ARGS]...

  Options:
    --verbose  Verbose printing
    --help     Show this message and exit.

  Commands:
    debug
    plot
    util

  >
  > bmtool plot
  Usage: bmtool plot [OPTIONS] COMMAND [ARGS]...

  Options:
    --config PATH  Configuration file to use, default: "simulation_config.json"
    --no-display   When set there will be no plot displayed, useful for saving
                   plots
    --help         Show this message and exit.

  Commands:
    connection  Display information related to neuron connections
    positions   Plot cell positions for a given set of populations
    raster      Plot the spike raster for a given population
    report      Plot the specified report using BMTK's default report plotter
  >
  ```


  - [Passive properties](#passive-properties)
  - [Current injection](#current-clamp)
  - [FI curve](#fi-curve)
  - [ZAP](#zap)
  - [Tuner](#single-cell-tuning)
  - [VHalf Segregation](#vhalf-segregation-module)





  ```python
  from bmtool.singlecell import Profiler
  profiler = Profiler(template_dir='templates', mechanism_dir = 'mechanisms', dt=0.1)
  ```




  ```python
  from bmtool.singlecell import load_allen_database_cells
  cell = load_allen_database_cells(path_to_SWC_file,path_to_json_file)
  ```





  ```python
  from bmtool.singlecell import Passive,run_and_plot
  import matplotlib.pyplot as plt
  sim = Passive('Cell_Cf', inj_amp=-100., inj_delay=1500., inj_dur=1000., tstop=2500., method='exp2')
  title = 'Passive Cell Current Injection'
  xlabel = 'Time (ms)'
  ylabel = 'Membrane Potential (mV)'
  X, Y = run_and_plot(sim, title, xlabel, ylabel, plot_injection_only=True)
  plt.gca().plot(*sim.double_exponential_fit(), 'r:', label='double exponential fit')
  plt.legend()
  plt.show()
  ```

      Injection location: Cell_Cf[0].soma[0](0.5)
      Recording: Cell_Cf[0].soma[0](0.5)._ref_v
      Running simulation for passive properties...

      V Rest: -70.21 (mV)
      Resistance: 128.67 (MOhms)
      Membrane time constant: 55.29 (ms)

      V_rest Calculation: Voltage taken at time 1500.0 (ms) is
      -70.21 (mV)

      R_in Calculation: dV/dI = (v_final-v_rest)/(i_final-i_start)
      (-83.08 - (-70.21)) / (-0.1 - 0)
      12.87 (mV) / 0.1 (nA) = 128.67 (MOhms)

      Tau Calculation: Fit a double exponential curve to the membrane potential response
      f(t) = a0 + a1*exp(-t/tau1) + a2*exp(-t/tau2)
      Constained by initial value: f(0) = a0 + a1 + a2 = v_rest
      Fit parameters: (a0, a1, a2, tau1, tau2) = (-83.06, -3306.48, 3319.33, 55.29, 55.15)
      Membrane time constant is determined from the slowest exponential term: 55.29 (ms)

      Sag potential: v_sag = v_peak - v_final = -0.66 (mV)
      Normalized sag potential: v_sag / (v_peak - v_rest) = 0.049





  ![png](readme_figures/output_8_1.png)







  ```python
  from bmtool.singlecell import CurrentClamp
  sim = CurrentClamp('Cell_Cf', inj_amp=350., inj_delay=1500., inj_dur=1000., tstop=3000., threshold=-15.)
  X, Y = run_and_plot(sim, title='Current Injection', xlabel='Time (ms)',
                      ylabel='Membrane Potential (mV)', plot_injection_only=True)
  plt.show()
  ```

      Injection location: Cell_Cf[1].soma[0](0.5)
      Recording: Cell_Cf[1].soma[0](0.5)._ref_v
      Current clamp simulation running...

      Number of spikes: 19





  ![png](readme_figures/output_10_1.png)







  ```python
  from bmtool.singlecell import FI
  sim = FI('Cell_Cf', i_start=0., i_stop=1000., i_increment=50., tstart=1500.,threshold=-15.)
  X, Y = run_and_plot(sim, title='FI Curve', xlabel='Injection (nA)', ylabel='# Spikes')
  plt.show()
  ```

      Injection location: Cell_Cf[21].soma[0](0.5)
      Recording: Cell_Cf[21].soma[0](0.5)._ref_v
      Running simulations for FI curve...

      Results
      Injection (nA): 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95
      Number of spikes: 0, 1, 10, 12, 15, 16, 17, 19, 20, 20, 21, 21, 22, 23, 23, 24, 25, 25, 26, 27





  ![png](readme_figures/output_12_1.png)







  ```python
  from bmtool.singlecell import ZAP
  sim = ZAP('Cell_Cf')
  X, Y = run_and_plot(sim)
  plt.show()
  ```

      Injection location: Cell_Cf[22].soma[0](0.5)
      Recording: Cell_Cf[22].soma[0](0.5)._ref_v
      ZAP current simulation running...

      Chirp current injection with frequency changing from 0 to 15 Hz over 15 seconds
      Impedance is calculated as the ratio of FFT amplitude of membrane voltage to FFT amplitude of chirp current





  ![png](readme_figures/output_14_1.png)






  ```bash
  bmtool util cell tune --builder
  ```


  ```bash
  bmtool util cell --template TemplateFile.hoc --mod-folder ./ tune --builder
  ```
  ![bmtool](./figures/figure2.png "Tuning Figure")








  ```bash
  > bmtool util cell vhseg --help

  Usage: bmtool util cell vhseg [OPTIONS]

    Alturki et al. (2016) V1/2 Automated Segregation Interface, simplify
    tuning by separating channel activation

  Options:
    --title TEXT
    --tstop INTEGER
    --outhoc TEXT         Specify the file you want the modified cell template
                          written to
    --outfolder TEXT      Specify the directory you want the modified cell
                          template and mod files written to (default: _seg)
    --outappend           Append out instead of overwriting (default: False)
    --debug               Print all debug statements
    --fminpa INTEGER      Starting FI Curve amps (default: 0)
    --fmaxpa INTEGER      Ending FI Curve amps (default: 1000)
    --fincrement INTEGER  Increment the FI Curve amps by supplied pA (default:
                          100)
    --infvars TEXT        Specify the inf variables to plot, skips the wizard.
                          (Comma separated, eg: inf_mech,minf_mech2,ninf_mech2)
    --segvars TEXT        Specify the segregation variables to globally set,
                          skips the wizard. (Comma separated, eg:
                          mseg_mech,nseg_mech2)
    --eleak TEXT          Specify the eleak var manually
    --gleak TEXT          Specify the gleak var manually
    --othersec TEXT       Specify other sections that a window should be
                          generated for (Comma separated, eg: dend[0],dend[1])
    --help                Show this message and exit.

  ```





  ```bash
  > bmtool util cell vhseg

  ? Select a cell:  CA3PyramidalCell
  Using section dend[0]
  ? Show other sections? (default: No)  Yes
  ? Select other sections (space bar to select):  done (2 selections)
  ? Select inf variables to plot (space bar to select):   done (5 selections)
  ? Select segregation variables [OR VARIABLES YOU WANT TO CHANGE ON ALL SEGMENTS at the same time] (space bar to select):  done (2 selections)
  ```



  ```bash
  bmtool util cell --template CA3PyramidalCell vhseg --othersec dend[0],dend[1] --infvars inf_im --segvars gbar_im --gleak gl_ichan2CA3 --eleak el_ichan2CA3
  ```

  Example:

  ![bmtool](./figures/figure4.png "Seg Figure")


  ``` bash
  bmtool util cell --hoc cell_template.hoc vhsegbuild --build
  bmtool util cell --hoc segmented_template.hoc vhsegbuild
  ```
  ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cell-hco)


  -[SynapticTuner](#synaptictuner)





  - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
  - [ReciprocalConnector](#recipical-connector---buiilding-connections-in-bmtk-network-model-with-reciprocal-probability-within-a-single-population-or-between-two-populations)
  - [CorrelatedGapJunction](#correlatedgapjunction)
  - [OneToOneSequentialConnector](#onetoonesequentialconnector)




  ```python
  from bmtk.builder import NetworkBuilder
  net = NetworkBuilder('example_net')
  net.add_nodes(N=100, pop_name='PopA',model_type = 'biophysical')
  net.add_nodes(N=100, pop_name='PopB',model_type = 'biophysical')

  background = NetworkBuilder('background')
  background.add_nodes(N=300,pop_name='tON',potential='exc',model_type='virtual')
  ```


  ```python
  from bmtool.connectors  import UnidirectionConnector
  connector = UnidirectionConnector(p=0.15, n_syn=1)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors  import ReciprocalConnector
  connector = ReciprocalConnector(p0=0.15, pr=0.06767705087, n_syn0=1, n_syn1=1,estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors import ReciprocalConnector, CorrelatedGapJunction
  connector = ReciprocalConnector(p0=0.15, pr=0.06, n_syn0=1, n_syn1=1, estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  net.add_edges(**connector.edge_params())
  gap_junc = CorrelatedGapJunction(p_non=0.1228,p_uni=0.56,p_rec=1,connector=connector)
  gap_junc.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  conn = net.add_edges(is_gap_junction=True, syn_weight=0.0000495, target_sections=None,afferent_section_id=0, afferent_section_pos=0.5,
  **gap_junc.edge_params())
  ```


  ```python
  from bmtool.connectors  import OneToOneSequentialConnector
  connector = OneToOneSequentialConnector()
  connector.setup_nodes(source=background.nodes(), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  connector.setup_nodes(target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```



  - [total_connection_matrix](#total_connection_matrix)
  - [percent_connection_matrix](#percent_connection_matrix)
  - [convergence_connection_matrix](#convergence_connection_matrix)
  - [divergence_connection_matrix](#divergence_connection_matrix)
  - [gap_junction_matrix](#gap_junction_matrix)
  - [connection_distance](#connection_distance)
  - [connection_histogram](#connection_histogram)
  - [plot_3d_positions](#plot_3d_positions)
  - [plot_3d_cell_rotation](#plot_3d_cell_rotation)







































  ```python
  bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True)
  ```



  ![png](readme_figures/output_35_0.png)





  - [Generate graph](#generate-graph)
  - [Plot Graph](#plot-graph)
  - [Connectioon table](#generate-graph-connection-table)



  ```python
  from bmtool import graphs
  import networkx as nx

  Graph = graphs.generate_graph(config='config.json',source='LA',target='LA')
  print("Number of nodes:", Graph.number_of_nodes())
  print("Number of edges:", Graph.number_of_edges())
  print("Node labels:", set(nx.get_node_attributes(Graph, 'label').values()))
  ```

      Number of nodes: 2000
      Number of edges: 84235
      Node labels: {'SOM', 'PNc', 'PNa', 'PV'}






  ```python
  graphs.plot_graph(Graph)
  ```







  ```python
  import pandas as pd
  graphs.export_node_connections_to_csv(Graph, 'node_connections.csv')
  df = pd.read_csv('node_connections.csv')
  df.head()
  ```




  <div>
  <style scoped>
      .dataframe tbody tr th:only-of-type {
          vertical-align: middle;
      }

      .dataframe tbody tr th {
          vertical-align: top;
      }

      .dataframe thead th {
          text-align: right;
      }
  </style>
  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>Unnamed: 0</th>
        <th>Node Label</th>
        <th>PNc Connections</th>
        <th>PV Connections</th>
        <th>SOM Connections</th>
        <th>PNa Connections</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>0</td>
        <td>PNa</td>
        <td>15</td>
        <td>11</td>
        <td>9</td>
        <td>6</td>
      </tr>
      <tr>
        <th>1</th>
        <td>1</td>
        <td>PNa</td>
        <td>24</td>
        <td>25</td>
        <td>6</td>
        <td>21</td>
      </tr>
      <tr>
        <th>2</th>
        <td>2</td>
        <td>PNa</td>
        <td>27</td>
        <td>28</td>
        <td>12</td>
        <td>25</td>
      </tr>
      <tr>
        <th>3</th>
        <td>3</td>
        <td>PNa</td>
        <td>19</td>
        <td>27</td>
        <td>15</td>
        <td>35</td>
      </tr>
      <tr>
        <th>4</th>
        <td>4</td>
        <td>PNa</td>
        <td>25</td>
        <td>11</td>
        <td>8</td>
        <td>16</td>
      </tr>
    </tbody>
  </table>
  </div>


pkgId: 2364f1761b22f6c73e00914586a53ecb1dc10efae6bee10fc5d2d0cd5d102202
name: python-bmtool
arch: src
version: 0.5.9.9
epoch: 0
release: 1
summary: BMTool
url: https://github.com/cyneuro/bmtool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bmtool-0.5.9.9-1.src.rpm
checksum_type: sha256
description:
  A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.

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


  - [Getting Started](#getting-started)
  - [CLI](#cli)
  - [Single Cell](#single-cell-module)
  - [Synapses](#synapses-module)
  - [Connectors](#connectors-module)
  - [Bmplot](#bmplot-module)
  - [Graphs](#graphs-module)



  **Installation**
  ```bash
  pip install bmtool
  ```
  For developers who will be pulling down additional updates to this repository regularly use the following instead.
  ```bash
  git clone https://github.com/cyneuro/bmtool.git
  cd bmtool
  python setup.py develop
  ```
  Then download updates (from this directory) with
  ```bash
  git pull
  ```



  ```bash
  > cd your_bmtk_model_directory
  > bmtool
  Usage: bmtool [OPTIONS] COMMAND [ARGS]...

  Options:
    --verbose  Verbose printing
    --help     Show this message and exit.

  Commands:
    debug
    plot
    util

  >
  > bmtool plot
  Usage: bmtool plot [OPTIONS] COMMAND [ARGS]...

  Options:
    --config PATH  Configuration file to use, default: "simulation_config.json"
    --no-display   When set there will be no plot displayed, useful for saving
                   plots
    --help         Show this message and exit.

  Commands:
    connection  Display information related to neuron connections
    positions   Plot cell positions for a given set of populations
    raster      Plot the spike raster for a given population
    report      Plot the specified report using BMTK's default report plotter
  >
  ```


  - [Passive properties](#passive-properties)
  - [Current injection](#current-clamp)
  - [FI curve](#fi-curve)
  - [ZAP](#zap)
  - [Tuner](#single-cell-tuning)
  - [VHalf Segregation](#vhalf-segregation-module)





  ```python
  from bmtool.singlecell import Profiler
  profiler = Profiler(template_dir='templates', mechanism_dir = 'mechanisms', dt=0.1)
  ```




  ```python
  from bmtool.singlecell import load_allen_database_cells
  cell = load_allen_database_cells(path_to_SWC_file,path_to_json_file)
  ```





  ```python
  from bmtool.singlecell import Passive,run_and_plot
  import matplotlib.pyplot as plt
  sim = Passive('Cell_Cf', inj_amp=-100., inj_delay=1500., inj_dur=1000., tstop=2500., method='exp2')
  title = 'Passive Cell Current Injection'
  xlabel = 'Time (ms)'
  ylabel = 'Membrane Potential (mV)'
  X, Y = run_and_plot(sim, title, xlabel, ylabel, plot_injection_only=True)
  plt.gca().plot(*sim.double_exponential_fit(), 'r:', label='double exponential fit')
  plt.legend()
  plt.show()
  ```

      Injection location: Cell_Cf[0].soma[0](0.5)
      Recording: Cell_Cf[0].soma[0](0.5)._ref_v
      Running simulation for passive properties...

      V Rest: -70.21 (mV)
      Resistance: 128.67 (MOhms)
      Membrane time constant: 55.29 (ms)

      V_rest Calculation: Voltage taken at time 1500.0 (ms) is
      -70.21 (mV)

      R_in Calculation: dV/dI = (v_final-v_rest)/(i_final-i_start)
      (-83.08 - (-70.21)) / (-0.1 - 0)
      12.87 (mV) / 0.1 (nA) = 128.67 (MOhms)

      Tau Calculation: Fit a double exponential curve to the membrane potential response
      f(t) = a0 + a1*exp(-t/tau1) + a2*exp(-t/tau2)
      Constained by initial value: f(0) = a0 + a1 + a2 = v_rest
      Fit parameters: (a0, a1, a2, tau1, tau2) = (-83.06, -3306.48, 3319.33, 55.29, 55.15)
      Membrane time constant is determined from the slowest exponential term: 55.29 (ms)

      Sag potential: v_sag = v_peak - v_final = -0.66 (mV)
      Normalized sag potential: v_sag / (v_peak - v_rest) = 0.049





  ![png](readme_figures/output_8_1.png)







  ```python
  from bmtool.singlecell import CurrentClamp
  sim = CurrentClamp('Cell_Cf', inj_amp=350., inj_delay=1500., inj_dur=1000., tstop=3000., threshold=-15.)
  X, Y = run_and_plot(sim, title='Current Injection', xlabel='Time (ms)',
                      ylabel='Membrane Potential (mV)', plot_injection_only=True)
  plt.show()
  ```

      Injection location: Cell_Cf[1].soma[0](0.5)
      Recording: Cell_Cf[1].soma[0](0.5)._ref_v
      Current clamp simulation running...

      Number of spikes: 19





  ![png](readme_figures/output_10_1.png)







  ```python
  from bmtool.singlecell import FI
  sim = FI('Cell_Cf', i_start=0., i_stop=1000., i_increment=50., tstart=1500.,threshold=-15.)
  X, Y = run_and_plot(sim, title='FI Curve', xlabel='Injection (nA)', ylabel='# Spikes')
  plt.show()
  ```

      Injection location: Cell_Cf[21].soma[0](0.5)
      Recording: Cell_Cf[21].soma[0](0.5)._ref_v
      Running simulations for FI curve...

      Results
      Injection (nA): 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95
      Number of spikes: 0, 1, 10, 12, 15, 16, 17, 19, 20, 20, 21, 21, 22, 23, 23, 24, 25, 25, 26, 27





  ![png](readme_figures/output_12_1.png)







  ```python
  from bmtool.singlecell import ZAP
  sim = ZAP('Cell_Cf')
  X, Y = run_and_plot(sim)
  plt.show()
  ```

      Injection location: Cell_Cf[22].soma[0](0.5)
      Recording: Cell_Cf[22].soma[0](0.5)._ref_v
      ZAP current simulation running...

      Chirp current injection with frequency changing from 0 to 15 Hz over 15 seconds
      Impedance is calculated as the ratio of FFT amplitude of membrane voltage to FFT amplitude of chirp current





  ![png](readme_figures/output_14_1.png)






  ```bash
  bmtool util cell tune --builder
  ```


  ```bash
  bmtool util cell --template TemplateFile.hoc --mod-folder ./ tune --builder
  ```
  ![bmtool](./figures/figure2.png "Tuning Figure")








  ```bash
  > bmtool util cell vhseg --help

  Usage: bmtool util cell vhseg [OPTIONS]

    Alturki et al. (2016) V1/2 Automated Segregation Interface, simplify
    tuning by separating channel activation

  Options:
    --title TEXT
    --tstop INTEGER
    --outhoc TEXT         Specify the file you want the modified cell template
                          written to
    --outfolder TEXT      Specify the directory you want the modified cell
                          template and mod files written to (default: _seg)
    --outappend           Append out instead of overwriting (default: False)
    --debug               Print all debug statements
    --fminpa INTEGER      Starting FI Curve amps (default: 0)
    --fmaxpa INTEGER      Ending FI Curve amps (default: 1000)
    --fincrement INTEGER  Increment the FI Curve amps by supplied pA (default:
                          100)
    --infvars TEXT        Specify the inf variables to plot, skips the wizard.
                          (Comma separated, eg: inf_mech,minf_mech2,ninf_mech2)
    --segvars TEXT        Specify the segregation variables to globally set,
                          skips the wizard. (Comma separated, eg:
                          mseg_mech,nseg_mech2)
    --eleak TEXT          Specify the eleak var manually
    --gleak TEXT          Specify the gleak var manually
    --othersec TEXT       Specify other sections that a window should be
                          generated for (Comma separated, eg: dend[0],dend[1])
    --help                Show this message and exit.

  ```





  ```bash
  > bmtool util cell vhseg

  ? Select a cell:  CA3PyramidalCell
  Using section dend[0]
  ? Show other sections? (default: No)  Yes
  ? Select other sections (space bar to select):  done (2 selections)
  ? Select inf variables to plot (space bar to select):   done (5 selections)
  ? Select segregation variables [OR VARIABLES YOU WANT TO CHANGE ON ALL SEGMENTS at the same time] (space bar to select):  done (2 selections)
  ```



  ```bash
  bmtool util cell --template CA3PyramidalCell vhseg --othersec dend[0],dend[1] --infvars inf_im --segvars gbar_im --gleak gl_ichan2CA3 --eleak el_ichan2CA3
  ```

  Example:

  ![bmtool](./figures/figure4.png "Seg Figure")


  ``` bash
  bmtool util cell --hoc cell_template.hoc vhsegbuild --build
  bmtool util cell --hoc segmented_template.hoc vhsegbuild
  ```
  ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cell-hco)


  -[SynapticTuner](#synaptictuner)





  - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
  - [ReciprocalConnector](#recipical-connector---buiilding-connections-in-bmtk-network-model-with-reciprocal-probability-within-a-single-population-or-between-two-populations)
  - [CorrelatedGapJunction](#correlatedgapjunction)
  - [OneToOneSequentialConnector](#onetoonesequentialconnector)




  ```python
  from bmtk.builder import NetworkBuilder
  net = NetworkBuilder('example_net')
  net.add_nodes(N=100, pop_name='PopA',model_type = 'biophysical')
  net.add_nodes(N=100, pop_name='PopB',model_type = 'biophysical')

  background = NetworkBuilder('background')
  background.add_nodes(N=300,pop_name='tON',potential='exc',model_type='virtual')
  ```


  ```python
  from bmtool.connectors  import UnidirectionConnector
  connector = UnidirectionConnector(p=0.15, n_syn=1)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors  import ReciprocalConnector
  connector = ReciprocalConnector(p0=0.15, pr=0.06767705087, n_syn0=1, n_syn1=1,estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors import ReciprocalConnector, CorrelatedGapJunction
  connector = ReciprocalConnector(p0=0.15, pr=0.06, n_syn0=1, n_syn1=1, estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  net.add_edges(**connector.edge_params())
  gap_junc = CorrelatedGapJunction(p_non=0.1228,p_uni=0.56,p_rec=1,connector=connector)
  gap_junc.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  conn = net.add_edges(is_gap_junction=True, syn_weight=0.0000495, target_sections=None,afferent_section_id=0, afferent_section_pos=0.5,
  **gap_junc.edge_params())
  ```


  ```python
  from bmtool.connectors  import OneToOneSequentialConnector
  connector = OneToOneSequentialConnector()
  connector.setup_nodes(source=background.nodes(), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  connector.setup_nodes(target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```



  - [total_connection_matrix](#total_connection_matrix)
  - [percent_connection_matrix](#percent_connection_matrix)
  - [connector_percent_matrix](#connector_percent_matrix)
  - [convergence_connection_matrix](#convergence_connection_matrix)
  - [divergence_connection_matrix](#divergence_connection_matrix)
  - [gap_junction_matrix](#gap_junction_matrix)
  - [connection_distance](#connection_distance)
  - [connection_histogram](#connection_histogram)
  - [plot_3d_positions](#plot_3d_positions)
  - [plot_3d_cell_rotation](#plot_3d_cell_rotation)










































  ```python
  bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True)
  ```



  ![png](readme_figures/output_35_0.png)





  - [Generate graph](#generate-graph)
  - [Plot Graph](#plot-graph)
  - [Connectioon table](#generate-graph-connection-table)



  ```python
  from bmtool import graphs
  import networkx as nx

  Graph = graphs.generate_graph(config='config.json',source='LA',target='LA')
  print("Number of nodes:", Graph.number_of_nodes())
  print("Number of edges:", Graph.number_of_edges())
  print("Node labels:", set(nx.get_node_attributes(Graph, 'label').values()))
  ```

      Number of nodes: 2000
      Number of edges: 84235
      Node labels: {'SOM', 'PNc', 'PNa', 'PV'}






  ```python
  graphs.plot_graph(Graph)
  ```







  ```python
  import pandas as pd
  graphs.export_node_connections_to_csv(Graph, 'node_connections.csv')
  df = pd.read_csv('node_connections.csv')
  df.head()
  ```




  <div>
  <style scoped>
      .dataframe tbody tr th:only-of-type {
          vertical-align: middle;
      }

      .dataframe tbody tr th {
          vertical-align: top;
      }

      .dataframe thead th {
          text-align: right;
      }
  </style>
  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>Unnamed: 0</th>
        <th>Node Label</th>
        <th>PNc Connections</th>
        <th>PV Connections</th>
        <th>SOM Connections</th>
        <th>PNa Connections</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>0</td>
        <td>PNa</td>
        <td>15</td>
        <td>11</td>
        <td>9</td>
        <td>6</td>
      </tr>
      <tr>
        <th>1</th>
        <td>1</td>
        <td>PNa</td>
        <td>24</td>
        <td>25</td>
        <td>6</td>
        <td>21</td>
      </tr>
      <tr>
        <th>2</th>
        <td>2</td>
        <td>PNa</td>
        <td>27</td>
        <td>28</td>
        <td>12</td>
        <td>25</td>
      </tr>
      <tr>
        <th>3</th>
        <td>3</td>
        <td>PNa</td>
        <td>19</td>
        <td>27</td>
        <td>15</td>
        <td>35</td>
      </tr>
      <tr>
        <th>4</th>
        <td>4</td>
        <td>PNa</td>
        <td>25</td>
        <td>11</td>
        <td>8</td>
        <td>16</td>
      </tr>
    </tbody>
  </table>
  </div>


pkgId: ffaaa620bf21313dc7515d7ee4fcce84d23640fba3da9a8e3b3d53467359399b
name: python-bng
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Convert between BNG grid refs (e.g. NT123456) and OSGB36 (EPSG:27700) coords
url: https://github.com/volcan01010/bng
rpm_license: GPLv3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bng-1.0.5-1.src.rpm
checksum_type: sha256
description:
  > Convert between BNG grid refs (e.g. NT123456) and OSGB36 (EPSG:27700) coords

  Coordinates in the [Ordnance Survey National Grid](https://en.wikipedia.org/wiki/Ordnance_Survey_National_Grid) or British National Grid are often defined by alphanumeric grid references that refer to grid squares.
  These are based on the `osgb36` (EPSG:27700) coordinate reference system but are not understood by most GIS software.
  This module contains Python functions to convert 4, 6, 8, or 10 figure alphanumeric grid references to/from pure `osgb36` coordinates.

  This code was originally published on a blog post: [Easily change coordinate projection systems in Python with pyproj](http://all-geo.org/volcan01010/2012/11/change-coordinates-with-pyproj/).
  The blog post contains more information and instructions for converting between coordinate systems using Python.



  BNG can be installed for Python 2.7 or Python 3 using pip:

  ```
  pip install bng
  ```



  The `to_osbg36` and `from_osbg36` functions are used to convert between tuples of OSGB36 (x, y) coordinates and alphanumeric grid references.



  BNG grid references can be converted to `osbg36` coordinates as follows.

  Single values:

  ```python
  import bng
  bng.to_osgb36('NT2755072950')

  ```

  The coordinates correspond to the southwest corner of the grid square described by the grid reference.

  For multiple values, use Python's zip function and list comprehension:

  ```python
  import bng
  gridrefs = ['HU431392', 'SJ637560', 'TV374354']
  x, y = zip(*[bng.to_osgb36(g) for g in gridrefs])
  x

  y

  ```



  BNG grid references can be created from`osbg36` coordinates as follows.

  Single values:
  ```python
  import bng
  bng.from_osgb36((327550, 672950), figs=6)

  ```

  The number of figures in the grid reference can be specified.
  The coordinates correspond to the southwest corner of the grid square containing the (x, y) coordinates.

  For multiple values, use Python's zip function and list comprehension:
  ```python
  import bng
  x = [443143, 363723, 537395]
  y = [1139158, 356004, 35394]
  [bng.from_osgb36(coords, figs=4) for coords in zip(x, y)]

  ```



  `BNG` can be combined with `pyproj` (see [blog post](http://all-geo.org/volcan01010/2012/11/change-coordinates-with-pyproj/)) to convert grid references to many different coordinate systems.

  BNG grid references can be converted to lat/lon as used by GPS systems (EPSG:4326) as follows:

  ```python
  import bng
  import pyproj


  wgs84=pyproj.CRS("EPSG:4326") # LatLon with WGS84 datum used by GPS units and Google Earth
  osgb36=pyproj.CRS("EPSG:27700") # UK Ordnance Survey, 1936 datum


  x, y = bng.to_osgb36('NT2755072950')
  pyproj.transform(osgb36, wgs84, x, y)

  ```

  **Note**: older versions of pyproj use `pyproj.Proj("+init=EPSG:4326")` syntax
  and [return coordinates in lon, lat
  order](https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6).

  GPS coordinates can be converted to BNG grid references as follows:

  ```python
  import bng
  import pyproj


  wgs84=pyproj.CRS("EPSG:4326") # LatLon with WGS84 datum used by GPS units and Google Earth
  osgb36=pyproj.CRS("EPSG:27700") # UK Ordnance Survey, 1936 datum


  lon = -3.1615548588213667
  lat = 55.944109545140932
  x, y = pyproj.transform(wgs84, osgb36, lat, lon)
  bng.from_osgb36((x, y))

  ```

  Note that for surveying work (i.e. < 1 m accuracy) it is necessary to make a geoid correction.
  Proj [uses](https://proj4.org/resource_files.html) grid correction files in NTv2 format to make this correction.
  The Ordnance Survey provide these files (OSTN2 transformation model) [on their website](https://www.ordnancesurvey.co.uk/business-and-government/help-and-support/navigation-technology/os-net/formats-for-developers.html).




  Install developer dependencies:

  ```bash
  pip install -r requirements.txt
  ```

  Run tests:

  ```bash
  pytest -vs test_bng.py
  ```


pkgId: 12b5eb01d58c86297abc57664627ae529f1c8cacb49bed6ce8e5aa350e63240a
name: python-bng-latlon
arch: src
version: 1.1
epoch: 0
release: 1
summary: Converts british national grid (OSBG36) to lat lon (WGS84) and vice versa.
url: https://github.com/fmalina/blocl-bnglatlon
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bng-latlon-1.1-1.src.rpm
checksum_type: sha256
description:
  Converts british national grid eastings and northings (OSBG36) to
  latitude and longitude (WGS84) and vice versa as used by
  <https://blocl.uk>
  Originally authored by [Hannah Fry](http://www.hannahfry.co.uk/).
  **NEW!** importable, installable, PEP8 styled, pure python, doctested,
  with optional numba compiler support for 10x speed


pkgId: 787b9bb32f22732bc38e6fba5417b3f5de2ac32833eae9c7b6b20aab21832f12
name: python-bnlearn
arch: src
version: 0.10.0
epoch: 0
release: 1
url: https://erdogant.github.io/bnlearn
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bnlearn-0.10.0-1.src.rpm
checksum_type: sha256
summary:
  Python package for Causal Discovery by learning the graphical structure of Bayesian networks, parameter learning, inference and sampling methods.

description:
  On the [documentation pages](https://erdogant.github.io/bnlearn/) you can find detailed information about the working of the ``bnlearn`` with many examples.



  ```bash
  conda create -n env_bnlearn python=3.10
  conda activate env_bnlearn
  ```

  ```bash
  pip install bnlearn
  ```

  ```bash
  pip install git+https://github.com/erdogant/bnlearn
  ```

  ```python

  import bnlearn as bn

  bn.structure_learning.fit()

  bn.independence_test(model, df, test='chi_square', prune=True)

  bn.parameter_learning.fit()

  bn.inference.fit()

  bn.predict()

  bn.sampling()

  bn.import_DAG()

  bn.import_example()

  bn.compare_networks()

  bn.plot()
  bn.plot_graphviz()

  bn.to_undirected()

  bn.df2onehot()

  bn.topological_sort()

  ```

  * inference
  * sampling
  * comparing two networks
  * loading bif files
  * Conversion of directed to undirected graphs


  Learning a Bayesian network can be split into the underneath problems which are all implemented in this package for both discrete, continuous and mixed data sets:
  * **Structure learning**: Given the data: Estimate a DAG that captures the dependencies between the variables.
     * There are multiple manners to perform structure learning.
        * Constraintsearch or PC
        * Exhaustivesearch
        * Hillclimbsearch
        * NaiveBayes
        * TreeSearch
            * Chow-liu
            * Tree-augmented Naive Bayes (TAN)
        * Direct-LiNGAM (for continuous and hybrid datasets)
        * ICA-LiNGAM (for continuous and hybrid datasets)
  * **Parameter learning**: Given the data and DAG: Estimate the (conditional) probability distributions of the individual variables.
  * **Inference**: Given the learned model: Determine the exact probability values for your queries.


  A structured overview of all examples are now available on the [documentation pages](https://erdogant.github.io/bnlearn/).

  * [Example: Learn structure on the Sprinkler dataset based on a simple dataframe](https://erdogant.github.io/bnlearn/pages/html/Examples.html#example-1)
  * [Example: Comparison method and scoring types types for structure learning](https://erdogant.github.io/bnlearn/pages/html/Examples.html#example-2)
  * [Example: Learn structure on  more complex dataset (Asia)](https://erdogant.github.io/bnlearn/pages/html/Examples.html#example-3)

  * [Example: Parameter learning using a DAG and dataframe](https://erdogant.github.io/bnlearn/pages/html/Examples.html#parameter-learning)

  * [Example: Make predictions on a dataframe using inference](https://erdogant.github.io/bnlearn/pages/html/Predict.html)

  * [Example: Sampling to create datasets](https://erdogant.github.io/bnlearn/pages/html/Sampling%20and%20datasets.html)

  * [Example: Create a Bayesian Network, learn its parameters from data and perform the inference](https://erdogant.github.io/bnlearn/pages/html/Examples.html#create-a-bayesian-network-learn-its-parameters-from-data-and-perform-the-inference)
  * [Example: Use case in the medical domain](https://erdogant.github.io/bnlearn/pages/html/UseCases.html)
  * [Example: Use case Titanic](https://erdogant.github.io/bnlearn/pages/html/UseCases.html#)

  * [Example: Interactive plotting](https://erdogant.github.io/bnlearn/pages/html/Plot.html#)
  * [Example: Static plotting](https://erdogant.github.io/bnlearn/pages/html/Plot.html#static-plot)
  * [Example: Comparison of two networks](https://erdogant.github.io/bnlearn/pages/html/Plot.html#comparison-of-two-networks)

  * [Example: Saving and loading of bnlearn models](https://erdogant.github.io/bnlearn/pages/html/saving%20and%20loading.html)
  * [Example: Data conversions such as creating sparse datamatrix from source-target and weights](https://erdogant.github.io/bnlearn/pages/html/dataframe%20conversions.html?highlight=target#)
  * [Example: Load DAG from BIF files](https://erdogant.github.io/bnlearn/pages/html/Examples.html?highlight=comparison#import-from-bif)
   

  ```python
      import bnlearn as bn
      
      df = bn.import_example()
      
  ```

  ```python
  Cloudy  Sprinkler  Rain  Wet_Grass
  0         0          1     0          1
  1         1          1     1          1
  2         1          0     1          1
  3         0          0     1          1
  4         1          0     1          1
  995       0          0     0          0
  996       1          0     0          0
  997       0          0     1          0
  998       1          1     0          1
  999       1          0     1          1
  ```
  ```python
      model = bn.structure_learning.fit(df)
      
      model = bn.independence_test(model, df)
      G = bn.plot(model)
  ```
  <p align="center">
    <img src="https://github.com/erdogant/bnlearn/blob/master/docs/figs/fig_sprinkler_sl.png" width="600" />
  </p>
  * Choosing various methodtypes and scoringtypes:
  ```python
      model_hc_bic  = bn.structure_learning.fit(df, methodtype='hc', scoretype='bic')
      model_hc_k2   = bn.structure_learning.fit(df, methodtype='hc', scoretype='k2')
      model_hc_bdeu = bn.structure_learning.fit(df, methodtype='hc', scoretype='bdeu')
      model_ex_bic  = bn.structure_learning.fit(df, methodtype='ex', scoretype='bic')
      model_ex_k2   = bn.structure_learning.fit(df, methodtype='ex', scoretype='k2')
      model_ex_bdeu = bn.structure_learning.fit(df, methodtype='ex', scoretype='bdeu')
      model_cl      = bn.structure_learning.fit(df, methodtype='cl', root_node='Wet_Grass')
      model_tan     = bn.structure_learning.fit(df, methodtype='tan', root_node='Wet_Grass', class_node='Rain')
  ```

  ```python
      import bnlearn as bn
      
      df = bn.import_example()
      
      model = bn.import_DAG('sprinkler', CPD=False)
      
      model_update = bn.parameter_learning.fit(model, df)
      
      G = bn.plot(model_update)
  ```

  ```python
      import bnlearn as bn
      model = bn.import_DAG('sprinkler')
      query = bn.inference.fit(model, variables=['Rain'], evidence={'Cloudy':1,'Sprinkler':0, 'Wet_Grass':1})
      print(query)
      print(query.df)
      
      query = bn.inference.fit(model, variables=['Rain'], evidence={'Cloudy':1})
      print(query)
      print(query.df)
  ```
  <hr>

  * https://erdogant.github.io/bnlearn/
  * http://www.bnlearn.com/bnrepository/
  * http://pgmpy.org

  Setting up and maintaining bnlearn has been possible thanks to users and contributors. Thanks to:
  <p align="left">
    <a href="https://github.com/erdogant/bnlearn/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=erdogant/bnlearn" />
    </a>
  </p>

  Please cite ``bnlearn`` in your publications if this is useful for your research. See column right for citation information.

  * Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)
  * Contributions are welcome.
  * If you wish to buy me a <a href="https://erdogant.github.io/donate/?currency=USD&amount=5">Coffee</a> for this work, it is very appreciated :)


pkgId: 42a7a2ec8bd16f3dc3d7986f28118ae4e17962a1656958329af70700b20c3e9e
name: python-bnlp-toolkit
arch: src
version: 4.0.3
epoch: 0
release: 1
summary: BNLP is a natural language processing toolkit for Bengali Language
url: https://github.com/sagorbrur/bnlp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bnlp-toolkit-4.0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/bnlp_toolkit)](https://pypi.org/project/bnlp-toolkit/)
  [![Downloads](https://static.pepy.tech/badge/bnlp_toolkit)](https://pepy.tech/project/bnlp_toolkit)

  BNLP is a natural language processing toolkit for Bengali Language. This tool will help you to **tokenize Bengali text**, **Embedding Bengali words**, **Embedding Bengali Document**, **Bengali POS Tagging**, **Bengali Name Entity Recognition**, **Bangla Text Cleaning** for Bengali NLP purposes.



  - Tokenization
     - [Basic Tokenizer](./docs/README.md#basic-tokenizer)
     - [NLTK Tokenizer](./docs/README.md#nltk-tokenization)
     - [Sentencepiece Tokenizer](./docs/README.md#bengali-sentencepiece-tokenization)
  - Embeddings
     - [Word2vec embedding](./docs/README.md#bengali-word2vec)
     - [Fasttext embedding](./docs/README.md#bengali-fasttext)
     - [Glove Embedding](./docs/README.md#bengali-glove-word-vectors)
     - [Doc2vec Document embedding](./docs/README.md#document-embedding)
  - Part of speech tagging
     - [CRF-based POS tagging](./docs/README.md#bengali-crf-pos-tagging)
  - Named Entity Recognition
     - [CRF-based NER](./docs/README.md#bengali-crf-ner)
  - [Text Cleaning](./docs/README.md#text-cleaning)
  - [Corpus](./docs/README.md#bengali-corpus-class)
     - Letters, vowels, punctuations, stopwords





    ```
    pip install bnlp_toolkit
    ```
    **or Upgrade**

    ```
    pip install -U bnlp_toolkit
    ```
    - Python: 3.8, 3.9, 3.10, 3.11
    - OS: Linux, Windows, Mac


  ```
  git clone https://github.com/sagorbrur/bnlp.git
  cd bnlp
  python setup.py install
  ```



  ```py
  from bnlp import BasicTokenizer

  tokenizer = BasicTokenizer()

  raw_text = "আমি বাংলায় গান গাই।"
  tokens = tokenizer(raw_text)
  print(tokens)

  ```


  Full documentation are available [here](https://github.com/sagorbrur/bnlp/tree/master/docs)

  If you are using previous version of **bnlp** check the documentation [archive](https://github.com/sagorbrur/bnlp/tree/master/docs/archive)



  Check [CONTRIBUTING.md](https://github.com/sagorbrur/bnlp/blob/master/CONTRIBUTING.md) page for details.




  * [Semantics Lab](https://www.facebook.com/lab.semantics/)
  * All the developers who are contributing to enrich Bengali NLP.


pkgId: 2a571b39f3b987c3e26592e1c2591d82024074c81415dfcb79a874e486300360
name: python-bnpm
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: A library of useful modules for data analysis.
url: https://github.com/RichieHakim/basic_neural_processing_modules
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bnpm-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/bnpm.svg)](https://badge.fury.io/py/bnpm)
  [![Downloads](https://pepy.tech/badge/bnpm)](https://pepy.tech/project/bnpm)
  [![repo size](https://img.shields.io/github/repo-size/RichieHakim/basic_neural_processing_modules)](https://github.com/RichieHakim/basic_neural_processing_modules/)


  Personal library of functions used in analyzing neural data.
  If you find a bug or just want to reach out: RichHakim@gmail.com


  Normal installation of `bnpm` does not install all possible dependencies; there are some specific functions that wrap libraries that may need to be installed separately on a case-by-case basis.

  Install stable version:
  ```
  pip install bnpm[core]
  ```

  If installing on a server or any computer without graphics/display, install using `core_cv2Headless`. If you accidentally installed the normal version, simply please uninstall `pip uninstall opencv-contrib-python` and install `pip install opencv-contrib-python-headless` instead.


  Install development version:
  ```
  pip install git+https://github.com/RichieHakim/basic_neural_processing_modules.git
  ```

  import with:
  ```
  import bnpm
  ```



  My favorites:
  - **`automatic_regression`** module
      - Allows for easy and fast hyperparameter optimization of regression models
      - Any model with a `fit` and `predict` method can be used (e.g. `sklearn` and similar)
      - Uses `optuna` for hyperparameter optimization

  Other useful functions:
  - Signal Processing:
      - `timeSeries.rolling_percentile_rq_multicore`
          - Fast rolling percentile calculation
      -  `timeSeries.event_triggered_traces`
          - Fast creation of a matrix of aligned traces relative to specified event times

  - Machine Learning:
      - `neural_networks` module
          - Has nice RNN regression and classification classes
      - `decomposition.torch_PCA`
          - Fast standard PCA using PyTorch
      - `similarity.orthogonalize`
          - Orthogonalize a matrix relative to a set of vectors using OLS or Gram-Schmidt process

  - Miscellaneous
      - `path_helpers.find_paths`
          - Find paths to files and/or folders in a directory. Searches recursively using regex.
      - `image_processing.play_video_cv2`
          - Plays and/or saves a 3D array as a video using OpenCV
      - `h5_handling.simple_save` and `h5_handling.simple_load`
          - Simple lazy loading and saving of dictionaries as nested h5 files


pkgId: 95956908eca1e5c3a640c7a0d66274fe27568c0b799e325e3092b26e0117fba4
name: python-bnunicodenormalizer
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Bangla Unicode Normalization Toolkit
url: https://github.com/mnansary/bnUnicodeNormalizer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bnunicodenormalizer-0.1.7-1.src.rpm
checksum_type: sha256
description:
  {'given': 'াটোবাকো',
   'normalized': 'টোবাকো',
   'ops': [{'after': 'টোবাকো',
            'before': 'াটোবাকো',
            'operation': 'InvalidUnicode'}]}
  ```
  **call to the normalizer returns a dictionary in the following format**
  * ```given``` = provided text
  * ```normalized``` = normalized text (gives None if during the operation length of the text becomes 0)
  * ```ops``` = list of operations (dictionary) that were executed in given text to create normalized text
  *  each dictionary in ops has:
      * ```operation```: the name of the operation / problem in given text
      * ```before``` : what the text looked like before the specific operation
      * ```after```  : what the text looks like after the specific operation
  **allow to use english text**
  ```python

  norm=Normalizer()
  print("without english:",norm("ASD123")["normalized"])

  norm=Normalizer(allow_english=True)
  print("with english:",norm("ASD123")["normalized"])
  ```
  > output
  ```
  without english: None
  with english: ASD123
  ```

  ```python
  '''
      initialize a normalizer
              args:
                  allow_english                   :   allow english letters numbers and punctuations [default:False]
                  keep_legacy_symbols             :   legacy symbols will be considered as valid unicodes[default:False]
                                                      '৺':Isshar
                                                      '৻':Ganda
                                                      'ঀ':Anji (not '৭')
                                                      'ঌ':li
                                                      'ৡ':dirgho li
                                                      'ঽ':Avagraha
                                                      'ৠ':Vocalic Rr (not 'ঋ')
                                                      '৲':rupi
                                                      '৴':currency numerator 1
                                                      '৵':currency numerator 2
                                                      '৶':currency numerator 3
                                                      '৷':currency numerator 4
                                                      '৸':currency numerator one less than the denominator
                                                      '৹':Currency Denominator Sixteen
                  legacy_maps                     :   a dictionay for changing legacy symbols into a more used  unicode
                                                      a default legacy map is included in the language class as well,
                                                      legacy_maps={'ঀ':'৭',
                                                                  'ঌ':'৯',
                                                                  'ৡ':'৯',
                                                                  '৵':'৯',
                                                                  '৻':'ৎ',
                                                                  'ৠ':'ঋ',
                                                                  'ঽ':'ই'}
                                                      pass-
                                                      * legacy_maps=None; for keeping the legacy symbols as they are
                                                      * legacy_maps="default"; for using the default legacy map
                                                      * legacy_maps=custom dictionary(type-dict) ; which will map your desired legacy symbol to any of symbol you want
                                                          * the keys in the custiom dicts must belong to any of the legacy symbols
                                                          * the values in the custiom dicts must belong to either vowels,consonants,numbers or diacritics
                                                          vowels         =   ['অ', 'আ', 'ই', 'ঈ', 'উ', 'ঊ', 'ঋ', 'এ', 'ঐ', 'ও', 'ঔ']
                                                          consonants     =   ['ক', 'খ', 'গ', 'ঘ', 'ঙ', 'চ', 'ছ','জ', 'ঝ', 'ঞ',
                                                                              'ট', 'ঠ', 'ড', 'ঢ', 'ণ', 'ত', 'থ', 'দ', 'ধ', 'ন',
                                                                              'প', 'ফ', 'ব', 'ভ', 'ম', 'য', 'র', 'ল', 'শ', 'ষ',
                                                                              'স', 'হ','ড়', 'ঢ়', 'য়','ৎ']
                                                          numbers        =    ['০', '১', '২', '৩', '৪', '৫', '৬', '৭', '৮', '৯']
                                                          vowel_diacritics       =   ['া', 'ি', 'ী', 'ু', 'ূ', 'ৃ', 'ে', 'ৈ', 'ো', 'ৌ']
                                                          consonant_diacritics   =   ['ঁ', 'ং', 'ঃ']
                                                          > for example you may want to map 'ঽ':Avagraha as 'হ' based on visual similiarity
                                                              (default:'ই')
                  ** legacy contions: keep_legacy_symbols and legacy_maps operates as follows
                      case-1) keep_legacy_symbols=True and legacy_maps=None
                      case-2) keep_legacy_symbols=True and legacy_maps=valid dictionary example:{'ঀ':'ক'}
                      case-3) keep_legacy_symbols=False and legacy_maps=None
                      case-4) keep_legacy_symbols=False and legacy_maps=valid dictionary example:{'ঽ':'ই','ৠ':'ঋ'}
  '''
  ```
  ```python
  my_legacy_maps={'ঌ':'ই',
                  'ৡ':'ই',
                  '৵':'ই',
                  'ৠ':'ই',
                  'ঽ':'ই'}
  text="৺,৻,ঀ,ঌ,ৡ,ঽ,ৠ,৲,৴,৵,৶,৷,৸,৹"

  norm=Normalizer(keep_legacy_symbols=True,legacy_maps=None)
  print("case-1 normalized text:  ",norm(text)["normalized"])

  norm=Normalizer(keep_legacy_symbols=True,legacy_maps=my_legacy_maps)
  print("case-2 normalized text:  ",norm(text)["normalized"])

  norm=Normalizer(keep_legacy_symbols=True)
  print("case-2 default normalized text:  ",norm(text)["normalized"])

  norm=Normalizer(keep_legacy_symbols=False,legacy_maps=None)
  print("case-3 normalized text:  ",norm(text)["normalized"])

  norm=Normalizer(keep_legacy_symbols=False,legacy_maps=my_legacy_maps)
  print("case-4 normalized text:  ",norm(text)["normalized"])

  norm=Normalizer(keep_legacy_symbols=False)
  print("case-4 default normalized text:  ",norm(text)["normalized"])
  ```
  > output
  ```
  case-1 normalized text:   ৺,৻,ঀ,ঌ,ৡ,ঽ,ৠ,৲,৴,৵,৶,৷,৸,৹
  case-2 normalized text:   ৺,৻,ঀ,ই,ই,ই,ই,৲,৴,ই,৶,৷,৸,৹
  case-2 default normalized text:   ৺,৻,ঀ,ঌ,ৡ,ঽ,ৠ,৲,৴,৵,৶,৷,৸,৹
  case-3 normalized text:   ,,,,,,,,,,,,,
  case-4 normalized text:   ,,,ই,ই,ই,ই,,,ই,,,,
  case-4 default normalized text:   ,,,,,,,,,,,,,
  ```

  * base operations available for all indic languages:
  ```python
  self.word_level_ops={"LegacySymbols"   :self.mapLegacySymbols,
                      "BrokenDiacritics" :self.fixBrokenDiacritics}
  self.decomp_level_ops={"BrokenNukta"             :self.fixBrokenNukta,
                      "InvalidUnicode"             :self.cleanInvalidUnicodes,
                      "InvalidConnector"           :self.cleanInvalidConnector,
                      "FixDiacritics"              :self.cleanDiacritics,
                      "VowelDiacriticAfterVowel"   :self.cleanVowelDiacriticComingAfterVowel}
  ```
  * extensions for bangla
  ```python
  self.decomp_level_ops["ToAndHosontoNormalize"]             =       self.normalizeToandHosonto

  self.decomp_level_ops["NormalizeConjunctsDiacritics"]      =       self.cleanInvalidConjunctDiacritics

  self.decomp_level_ops["ComplexRootNormalization"]          =       self.convertComplexRoots
  ```

  **In all examples (a) is the non-normalized form and (b) is the normalized form**
  * Broken diacritics:
  ```

  (a)'আরো'==(b)'আরো' ->  False
      (a) breaks as:['আ', 'র', 'ে', 'া']
      (b) breaks as:['আ', 'র', 'ো']

  (a)পৌঁছে==(b)পৌঁছে ->  False
      (a) breaks as:['প', 'ে', 'ৗ', 'ঁ', 'ছ', 'ে']
      (b) breaks as:['প', 'ৌ', 'ঁ', 'ছ', 'ে']

  (a)সংস্কৄতি==(b)সংস্কৃতি ->  False
      (a) breaks as:['স', 'ং', 'স', '্', 'ক', 'ৄ', 'ত', 'ি']
      (b) breaks as:['স', 'ং', 'স', '্', 'ক', 'ৃ', 'ত', 'ি']
  ```
  * Nukta Normalization:
  ```
  Example-1:
  (a)কেন্দ্রীয়==(b)কেন্দ্রীয় ->  False
      (a) breaks as:['ক', 'ে', 'ন', '্', 'দ', '্', 'র', 'ী', 'য', '়']
      (b) breaks as:['ক', 'ে', 'ন', '্', 'দ', '্', 'র', 'ী', 'য়']
  Example-2:
  (a)রযে়ছে==(b)রয়েছে ->  False
      (a) breaks as:['র', 'য', 'ে', '়', 'ছ', 'ে']
      (b) breaks as:['র', 'য়', 'ে', 'ছ', 'ে']
  Example-3:
  (a)জ়ন্য==(b)জন্য ->  False
      (a) breaks as:['জ', '়', 'ন', '্', 'য']
      (b) breaks as:['জ', 'ন', '্', 'য']
  ```
  * Invalid hosonto
  ```

  (a)দুই্টি==(b)দুইটি-->False
      (a) breaks as ['দ', 'ু', 'ই', '্', 'ট', 'ি']
      (b) breaks as ['দ', 'ু', 'ই', 'ট', 'ি']

  (a)এ্তে==(b)এতে-->False
      (a) breaks as ['এ', '্', 'ত', 'ে']
      (b) breaks as ['এ', 'ত', 'ে']

  (a)নেট্ওয়ার্ক==(b)নেটওয়ার্ক-->False
      (a) breaks as ['ন', 'ে', 'ট', '্', 'ও', 'য়', 'া', 'র', '্', 'ক']
      (b) breaks as ['ন', 'ে', 'ট', 'ও', 'য়', 'া', 'র', '্', 'ক']

  (a)এস্আই==(b)এসআই-->False
      (a) breaks as ['এ', 'স', '্', 'আ', 'ই']
      (b) breaks as ['এ', 'স', 'আ', 'ই']

  (a)'চু্ক্তি'==(b)'চুক্তি' ->  False
      (a) breaks as:['চ', 'ু', '্', 'ক', '্', 'ত', 'ি']
      (b) breaks as:['চ', 'ু','ক', '্', 'ত', 'ি']

  (a)'যু্ক্ত'==(b)'যুক্ত' ->   False
      (a) breaks as:['য', 'ু', '্', 'ক', '্', 'ত']
      (b) breaks as:['য', 'ু', 'ক', '্', 'ত']

  (a)'কিছু্ই'==(b)'কিছুই' ->   False
      (a) breaks as:['ক', 'ি', 'ছ', 'ু', '্', 'ই']
      (b) breaks as:['ক', 'ি', 'ছ', 'ু','ই']
  ```
  * To+hosonto:
  ```

  (a)বুত্পত্তি==(b)বুৎপত্তি-->False
      (a) breaks as ['ব', 'ু', 'ত', '্', 'প', 'ত', '্', 'ত', 'ি']
      (b) breaks as ['ব', 'ু', 'ৎ', 'প', 'ত', '্', 'ত', 'ি']

  (a)উত্স==(b)উৎস-->False
      (a) breaks as ['উ', 'ত', '্', 'স']
      (b) breaks as ['উ', 'ৎ', 'স']
  ```
  * Unwanted doubles(consecutive doubles):
  ```

  (a)'যুুদ্ধ'==(b)'যুদ্ধ' ->  False
      (a) breaks as:['য', 'ু', 'ু', 'দ', '্', 'ধ']
      (b) breaks as:['য', 'ু', 'দ', '্', 'ধ']

  (a)'দুুই'==(b)'দুই' ->   False
      (a) breaks as:['দ', 'ু', 'ু', 'ই']
      (b) breaks as:['দ', 'ু', 'ই']

  (a)'প্রকৃৃতির'==(b)'প্রকৃতির' ->   False
      (a) breaks as:['প', '্', 'র', 'ক', 'ৃ', 'ৃ', 'ত', 'ি', 'র']
      (b) breaks as:['প', '্', 'র', 'ক', 'ৃ', 'ত', 'ি', 'র']

  (a)আমাকোা==(b)'আমাকো'->   False
      (a) breaks as:['আ', 'ম', 'া', 'ক', 'ে', 'া', 'া']
      (b) breaks as:['আ', 'ম', 'া', 'ক', 'ো']
  ```
  * Vowwels and modifier followed by vowel diacritics:
  ```

  (a)উুলু==(b)উলু-->False
      (a) breaks as ['উ', 'ু', 'ল', 'ু']
      (b) breaks as ['উ', 'ল', 'ু']

  (a)আর্কিওোলজি==(b)আর্কিওলজি-->False
      (a) breaks as ['আ', 'র', '্', 'ক', 'ি', 'ও', 'ো', 'ল', 'জ', 'ি']
      (b) breaks as ['আ', 'র', '্', 'ক', 'ি', 'ও', 'ল', 'জ', 'ি']

  (a)একএে==(b)একত্রে-->False
      (a) breaks as ['এ', 'ক', 'এ', 'ে']
      (b) breaks as ['এ', 'ক', 'ত', '্', 'র', 'ে']
  ```
  * Repeated folas:
  ```

  (a)গ্র্রামকে==(b)গ্রামকে-->False
      (a) breaks as ['গ', '্', 'র', '্', 'র', 'া', 'ম', 'ক', 'ে']
      (b) breaks as ['গ', '্', 'র', 'া', 'ম', 'ক', 'ে']
  ```

  **The normalization is purely based on how bangla text is used in ```Bangladesh```(bn:bd). It does not necesserily cover every variation of textual content available at other regions**

  * clone the repository
  * change working directory to ```tests```
  * run: ```python3 -m unittest test_normalizer.py```

  * for reporting an issue please provide the specific information
      *  invalid text
      *  expected valid text
      *  why is the output expected
      *  clone the repository
      *  add a test case in **tests/test_normalizer.py** after **line no:91**
      ```python
          
          
          self.assertEqual(norm('ASD1234')["normalized"],None)
          self.assertEqual(ennorm('ASD1234')["normalized"],'ASD1234')
          
          self.assertEqual(norm('িত')["normalized"],'ত')
          self.assertEqual(norm('সং্যুক্তি')["normalized"],"সংযুক্তি")
          
          self.assertEqual(norm("অজানা্")["normalized"],"অজানা")
          
          '''
              
              
              self.assertEqual(norm(invalid text)["normalized"],expected output)
                          or
              self.assertEqual(ennorm(invalid text)["normalized"],expected output) <----- for including english text
          '''
          
      ```
      * perform the unit testing
      * make sure the unit test fails under true conditions

  * to use indic language normalizer for 'devanagari', 'gujarati', 'odiya', 'tamil', 'panjabi', 'malayalam','sylhetinagri'
  ```python
  from bnunicodenormalizer import IndicNormalizer
  norm=IndicNormalizer('devanagari')
  ```
  * initialization
  ```python
  '''
      initialize a normalizer
      args:
          language                        :   language identifier from 'devanagari', 'gujarati', 'odiya', 'tamil', 'panjabi', 'malayalam','sylhetinagri'
          allow_english                   :   allow english letters numbers and punctuations [default:False]
  '''
  ```

  * Authors: [Bengali.AI](https://bengali.ai/) in association with OCR Team , [APSIS Solutions Limited](https://apsissolutions.com/)
  * **Cite Our Work**
  ```bibtext
  @inproceedings{ansary-etal-2024-unicode-normalization,
      title = "{U}nicode Normalization and Grapheme Parsing of {I}ndic Languages",
      author = "Ansary, Nazmuddoha  and
        Adib, Quazi Adibur Rahman  and
        Reasat, Tahsin  and
        Sushmit, Asif Shahriyar  and
        Humayun, Ahmed Imtiaz  and
        Mehnaz, Sazia  and
        Fatema, Kanij  and
        Rashid, Mohammad Mamun Or  and
        Sadeque, Farig",
      editor = "Calzolari, Nicoletta  and
        Kan, Min-Yen  and
        Hoste, Veronique  and
        Lenci, Alessandro  and
        Sakti, Sakriani  and
        Xue, Nianwen",
      booktitle = "Proceedings of the 2024 Joint International Conference on Computational Linguistics, Language Resources and Evaluation (LREC-COLING 2024)",
      month = may,
      year = "2024",
      address = "Torino, Italia",
      publisher = "ELRA and ICCL",
      url = "https://aclanthology.org/2024.lrec-main.1479",
      pages = "17019--17030",
      abstract = "Writing systems of Indic languages have orthographic syllables, also known as complex graphemes, as unique horizontal units. A prominent feature of these languages is these complex grapheme units that comprise consonants/consonant conjuncts, vowel diacritics, and consonant diacritics, which, together make a unique Language. Unicode-based writing schemes of these languages often disregard this feature of these languages and encode words as linear sequences of Unicode characters using an intricate scheme of connector characters and font interpreters. Due to this way of using a few dozen Unicode glyphs to write thousands of different unique glyphs (complex graphemes), there are serious ambiguities that lead to malformed words. In this paper, we are proposing two libraries: i) a normalizer for normalizing inconsistencies caused by a Unicode-based encoding scheme for Indic languages and ii) a grapheme parser for Abugida text. It deconstructs words into visually distinct orthographic syllables or complex graphemes and their constituents. Our proposed normalizer is a more efficient and effective tool than the previously used IndicNLP normalizer. Moreover, our parser and normalizer are also suitable tools for general Abugida text processing as they performed well in our robust word-based and NLP experiments. We report the pipeline for the scripts of 7 languages in this work and develop the framework for the integration of more scripts.",
  }
  ```


pkgId: 25369f8662c16d4dd10a5801a92b65c8394621feece81be62cba61515fb7c573
name: python-boa-restrictor
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A custom Python linter from Ambient
url: https://github.com/ambient-innovation/boa-restrictor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boa-restrictor-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI release](https://img.shields.io/pypi/v/boa-restrictor.svg)](https://pypi.org/project/boa-restrictor/)
  [![Downloads](https://static.pepy.tech/badge/boa-restrictor)](https://pepy.tech/project/boa-restrictor)
  [![Coverage](https://img.shields.io/badge/Coverage-100.0%25-success)](https://github.com/ambient-innovation/boa-restrictor/actions?workflow=CI)
  [![Linting](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Coding Style](https://img.shields.io/badge/code%20style-Ruff-000000.svg)](https://github.com/astral-sh/ruff)
  [![Documentation Status](https://readthedocs.org/projects/boa-restrictor/badge/?version=latest)](https://boa-restrictor.readthedocs.io/en/latest/?badge=latest)

  Welcome to the **boa-restrictor** - a custom Python linter from Ambient

  * [PyPI](https://pypi.org/project/boa-restrictor/)
  * [GitHub](https://github.com/ambient-innovation/boa-restrictor)
  * [Full documentation](https://boa-restrictor.readthedocs.io/en/latest/index.html)
  * Creator & Maintainer: [Ambient Digital](https://ambient.digital/)






  This rule enforces that functions and methods don't contain any positional arguments.

  This will make refactorings easier, is more explicit,
  and you avoid the [boolean bug trap](https://adamj.eu/tech/2021/07/10/python-type-hints-how-to-avoid-the-boolean-trap/).

  *Wrong:*

  ```python
  def my_func(a, b):
      pass
  ```

  *Correct:*

  ```python
  def my_func(*, a, b):
      pass
  ```



  This rule will enforce that you add a return type-hint to all methods and functions that contain a `return` statement.
  This way we can be more explicit and let the IDE help the next developer because it will add warnings if you use
  wrong types.

  *Wrong:*

  ```python
  def my_func(a, b):
      return a * b
  ```

  *Correct:*

  ```python
  def my_func(a, b) -> int:
      return a * b
  ```



  Add the following to your .pre-commit-config.yaml file:

  ```yaml
    - repo: https://github.com/ambient-innovation/boa-restrictor
      rev: v1.0.1
      hooks:
        - id: boa-restrictor
          args: [ --config=pyproject.toml ]
  ```

  Now you can run the linter manually:

      pre-commit run --all-files boa-restrictor






  You can easily exclude certain files, for example, your tests, by using the `exclude` parameter from `pre-commit`:

  ```yaml
    - repo: https://github.com/ambient-innovation/boa-restrictor
      rev: v1.0.1
      hooks:
        - id: boa-restrictor
          ...
          exclude: |
            (?x)^(
              /.*/tests/.*
              |.*/test_.*\.py
            )$
  ```



  You can disable any rule in your `pyproject.toml` file as follows:

  ```toml
  [tool.boa-restrictor]
  exclude = [
      "PBR001",
      "PBR002",
  ]
  ```



  If you are using `ruff`, you need to tell it about our linting rules. Otherwise, ruff will remove all `# noqa`
  statements from your codebase.

  ```toml
  [tool.ruff.lint]


  external = ["PBR"]
  ```

  https://docs.astral.sh/ruff/settings/#lint_extend-unsafe-fixes





  - Create a Python virtualenv and activate it
  - Install "pip-tools" with `pip install -U pip-tools`
  - Compile the requirements with `pip-compile --extra dev, -o requirements.txt pyproject.toml --resolver=backtracking`
  - Sync the dependencies with your virtualenv with `pip-sync`



  - Create a new branch for your feature
  - Change the dependency in your requirements.txt to a local (editable) one that points to your local file system:
    `-e /Users/workspace/boa-restrictor` or via pip  `pip install -e /Users/workspace/boa-restrictor`
  - Ensure the code passes the tests
  - Create a pull request



  - Run tests
    ````
    pytest --ds settings tests
    ````

  - Check coverage
    ````
    coverage run -m pytest tests
    coverage report -m
    ````



  We use pre-push hooks to ensure that only linted code reaches our remote repository and pipelines aren't triggered in
  vain.

  To enable the configured pre-push hooks, you need to [install](https://pre-commit.com/) pre-commit and run once:

      pre-commit install -t pre-push -t pre-commit --install-hooks

  This will permanently install the git hooks for both, frontend and backend, in your local
  [`.git/hooks`](./.git/hooks) folder.
  The hooks are configured in the [`.pre-commit-config.yaml`](templates/.pre-commit-config.yaml.tpl).

  You can check whether hooks work as intended using the [run](https://pre-commit.com/#pre-commit-run) command:

      pre-commit run [hook-id] [options]

  Example: run single hook

      pre-commit run ruff --all-files --hook-stage push

  Example: run all hooks of pre-push stage

      pre-commit run --all-files --hook-stage push



  - To build the documentation, run: `sphinx-build docs/ docs/_build/html/`.
  - Open `docs/_build/html/index.html` to see the documentation.





  - Fetch the latest changes in GitHub mirror and push them
  - Trigger new build at ReadTheDocs.io (follow instructions in admin panel at RTD) if the GitHub webhook is not yet set
    up.



  - Update documentation about new/changed functionality

  - Update the `Changelog`

  - Increment version in main `__init__.py`

  - Create pull request / merge to main

  - This project uses the flit package to publish to PyPI. Thus, publishing should be as easy as running:
    ```
    flit publish
    ```

    To publish to TestPyPI use the following to ensure that you have set up your .pypirc as
    shown [here](https://flit.readthedocs.io/en/latest/upload.html#using-pypirc) and use the following command:

    ```
    flit publish --repository testpypi
    ```



  To be able to use the latest version in pre-commit, you have to create a git tag for the current commit.
  So please tag your commit and push it to GitHub.



  Please note that this package supports the [ambient-package-update](https://pypi.org/project/ambient-package-update/).
  So you don't have to worry about the maintenance of this package. This updater is rendering all important
  configuration and setup files. It works similar to well-known updaters like `pyupgrade` or `django-upgrade`.

  To run an update, refer to the [documentation page](https://pypi.org/project/ambient-package-update/)
  of the "ambient-package-update".


pkgId: 85165a92a229a316915bf127dce19e1a285caab8ae751d4eb338951e6465e4d6
name: python-boa-str
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Convert strings to snakecase
url: https://github.com/astronomerio/boa
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boa-str-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Boa is a Python package for normalizing and converting strings to snakecase.
  For example, it translates the user-defined event ``'User Buys Item'`` to ``'user_buys_item'`` which can then be used in a file path in S3, or as the name of a schema or table in Redshift.
  It also handles the more complex cases such as stripping punctuation and converting words from camelCase or PascalCase to snake_case (see examples below).


pkgId: 2e07f022de683d8a117c05bf148ed69a3f5b34f0107ad7834f5590b533e483e9
name: python-board2pdf
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: KiCAD Gerber PDF Generator
url: https://pypi.org/project/board2pdf/
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-board2pdf-1.8.0-1.src.rpm
checksum_type: sha256
description:
  Board2Pdf is a KiCad Action Plugin to create good looking pdf files from the board. The outputted pdf is vector based
  and searchable.

  Two examples of what the plugin can output can be found here:<br>
  [armory-Assembly.pdf](https://gitlab.com/dennevi/Board2Pdf/-/raw/main/resources/armory-Assembly.pdf "USB armory from WithSecure Foundry") (
  1 982 kB) Project is
  found [here](https://github.com/f-secure-foundry/usbarmory "USB armory from WithSecure Foundry")<br>
  [hackrf-one-Assembly.pdf](https://gitlab.com/dennevi/Board2Pdf/-/raw/main/resources/hackrf-one-Assembly.pdf "HackRF by Great Scott Gadgets") (
  1 579 kB) Project is found [here](https://github.com/greatscottgadgets/hackrf "HackRF by Great Scott Gadgets")<br>

  When loaded the plugin looks like this. Here the user can configure how the pdf shall look.
  ![Screenshot](https://gitlab.com/dennevi/Board2Pdf/-/raw/main/resources/screenshot.png "Screenshot")

  This plugin ONLY works with the KiCad 6.0 and later. It does NOT work with KiCad 5.1.x or earlier versions.

  [https://gitlab.com/dennevi/Board2Pdf/](https://gitlab.com/dennevi/Board2Pdf/)



  The easiest way to install is to open KiCad -> Plugin And Content Manager. Select Board2Pdf in the Plugins tab, press
  Install and then Apply Changes.

  If you only want to use the CLI (use Board2Pdf from the command line) you can also install Board2Pdf using pip: `pip install board2pdf`. Then you can use the Board2Pdf CLI by calling board2pdf just like any other application installed from pip.

  For instructions on manual installation from the repo, see [Wiki - Installation](https://gitlab.com/dennevi/Board2Pdf/-/wikis/Installation)

  Also, see Dependencies below.



  For basic functionality Board2Pdf uses [pypdf](https://github.com/py-pdf/pypdf) which is included when installing Board2Pdf. You don’t need to install any dependencies if this functionality is enough for you.

  If you install [PyMuPDF](https://github.com/pymupdf/PyMuPDF) you can create the pdf files faster. It also enables you to convert the output file to SVG, and it has better support for bookmarks (table of content).

  Board2Pdf uses [pdfCropMargins](https://github.com/abarker/pdfCropMargins) for some of the crop and scaling options. pdfCropMargins includes PyMuPDF so if you choose to install pdfCropMargins you don't have to install PyMuPDF.

  More information in [Wiki - Install dependencies](https://gitlab.com/dennevi/Board2Pdf/-/wikis/Install-dependencies).



  When PyMuPDF (fitz) is installed with pip, KiCad crashes with a segmentation fault when Board2Pdf is loaded. Board2Pdf loads when the PCB Editor loads, so the crash happens directly when the PCB Editor is started. If this happens to you, you have two options:
  1. Uninstall PyMuPDF using `python -m pip uninstall --upgrade PyMuPDF` or `pip uninstall --upgrade PyMuPDF` and use pypdf instead.
  2. Uninstall PyMuPDF as in (1), but install it again using the apt package manager: `sudo apt install python3-fitz`



  The plugin includes a default configuration which should make it more or less self explanatory if you test it out. The
  basic idea is that each template will result in a page in the pdf file that\'s created by this plugin. You can enable
  any number of templates to get different views and color modes of the pcb. Each template can be individually configured
  to give the desired output. It\'s completely up to you which layers to show, and which colors the layers shall have.

  More information can be found in the [Wiki - Usage GUI](https://gitlab.com/dennevi/Board2Pdf/-/wikis/Usage---GUI).



  Board2Pdf can be executed from the command line using `python board2pdf-cli.py {PROJECT}.kicad_pcb`. If installed using pip install the binary can be executed using `board2pdf {PROJECT}.kicad_pcb`.

  More information can be found in the [Wiki - Usage CLI](https://gitlab.com/dennevi/Board2Pdf/-/wikis/Usage---CLI).



  First search the [KiCad forum](https://forum.kicad.info/) to see if someone else has asked the same thing. If not, post
  your question in the forum and tag me by writing @albin. That way I will see your post and answer as soon as I can.



  If you find a bug, please add an issue in the GitLab project.

  If you make some improvements, please issue a pull request. All help is appreciated!

  Read DEVELOPMENT.md for information on how to build Board2Pdf.



  This script is written by Albin Dennevi, with contributions from [others](https://gitlab.com/dennevi/Board2Pdf/-/graphs/main?ref_type=heads). If you need to come in contact with me please use the KiCad forum as described under Support. But for bugs and feature requests, please add an issue in GitLab.

  Credit goes to qu1ck, the author of the [InteractiveHtmlBom](https://github.com/openscopeproject/InteractiveHtmlBom)
  plugin. I used the GUI of this project as a starting point when making the GUI for this project.



  This plugin is licensed under the open-source GNU GPL license, version 3.0 or later. A copy of the license is included in this software, and it can also be viewed [here](https://www.gnu.org/licenses/gpl-3.0.en.html). This is the same license as pdfCropMargins is licensed under, personally I would've choosen a more open license.



  This project is considered to be finished. When serious bugs are reported I will try my best to fix them, but don\'t
  expect too much progress in adding features from my side.


pkgId: b7a0a8a7298a0871490f8cf09c19f1971b4d47876ced0ffeaa26d85661fc51ee
name: python-boardlib
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Utilities for interacting with climbing board APIs
url: https://github.com/lemeryfertitta/BoardLib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boardlib-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Utilities for interacting with (undocumented) climbing board APIs.



  `python3 -m pip install boardlib`





  To download the climb database for a given board:

  `boardlib database <board_name> <database_path>`

  This command will first download a [sqlite](https://www.sqlite.org/index.html) database file to the given path. After downloading, the database will then use the undocumented sync API to synchronize it with the latest available data. The database contains only the publicly available data. User data is not synchronized. If a database already exists as `database_path`, the command will skip the download step and only perform the synchronization.

  NOTE: The Moonboard is not currently supported for the database command. Contributions are welcome.



  All [Aurora Climbing](https://auroraclimbing.com/) based boards (Kilter, Tension, etc.).



  To download your logbook entries for a given board:

  `boardlib logbook <board_name> --username=<username> --output=<output_file_name>.csv --grade-type="hueco" --database=<local_database_file>`

  This outputs a CSV file with the following fields:

  ```json
  ["board", "angle", "climb_name", "date", "logged_grade", "displayed_grade", "difficulty", "is_benchmark", "tries", "is_mirror", "sessions_count", "tries_total", "is_repeat", "is_ascent", "comment"]
  ```

  For example, the command

  `boardlib tension --username="Luke EF" --output="tension.csv" --grade-type="hueco" --database="tension.db"`

  would output a file named `tension.csv` with the following contents:

  ```
  board,angle,climb_name,date,logged_grade,displayed_grade,difficulty,is_benchmark,tries,is_mirror,sessions_count,tries_total,is_repeat,is_ascent,comment
  tension,40,trash bag better,2024-06-17 16:21:23,V3,V3,16.0,False,3,False,1,3,False,True,
  tension,40,Bumble,2024-06-17 16:28:23,V3,V3,16.0,True,1,True,1,1,False,True,
  tension,40,sender2,2024-06-17 16:38:06,V5,V5,20.0,False,2,False,1,2,False,True,
  ...
  ```
  When no local database is provided, displayed_grade and difficulty remain empty.
  See `boardlib --help` for a full list of supported board names and feature flags.



  Currently all [Aurora Climbing](https://auroraclimbing.com/) based boards (Kilter, Tension, etc.) and all variations of the [Moonboard](https://moonboard.com/) should be supported.



  Please create an issue in the [issue tracker](https://github.com/lemeryfertitta/BoardLib/issues) to report bugs or request additional features. Contributions are welcome and appreciated.


pkgId: 78a3df67b0a6d304eca6b037b7e3af9cc416eefd5fd81559209bfec37749275e
name: python-boario
arch: src
version: 0.5.10
epoch: 0
release: 1
summary: BoARIO : The Adaptative Regional Input Output model in python.
url: https://pypi.org/project/boario/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boario-0.5.10-1.src.rpm
checksum_type: sha256
description:
  Indirect impact modeling is tied to a lot of uncertainties and complex dynamics.
  Any results produced with `BoARIO` should be interpreted with great care. Do not
  hesitate to contact the author when using the model !


pkgId: c89a53c5768cc23e293eea2d389df9f7d1f7f442e75d22914b5dcae4dda1ea8e
name: python-bob
arch: src
version: 12.1.1
epoch: 0
release: 1
url: https://pypi.org/project/bob/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bob-12.1.1-1.src.rpm
checksum_type: sha256
summary:
  Bob is a free signal-processing and machine learning toolbox originally developed by the Biometrics group at Idiap Research Institute, in Switzerland.

description:
  [![badge doc](https://img.shields.io/badge/docs-v12.1.1-orange.svg)](https://www.idiap.ch/software/bob/docs/bob/bob/v12.1.1/index.html)
  [![badge pipeline](https://gitlab.idiap.ch/bob/bob/badges/v12.1.1/pipeline.svg)](https://gitlab.idiap.ch/bob/bob/commits/v12.1.1)
  [![badge coverage](https://gitlab.idiap.ch/bob/bob/badges/v12.1.1/coverage.svg)](https://gitlab.idiap.ch/bob/bob/commits/v12.1.1)
  [![badge gitlab](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/bob/bob)



  [Bob](https://www.idiap.ch/software/bob) is a free signal-processing and machine
  learning toolbox originally developed by the Biometrics group at the
  [Idiap Research Institute](https://www.idiap.ch), Switzerland.

  The toolbox is written in [Python](https://www.python.org) and is designed to be
  both efficient and reduce development time. It is composed of a reasonably large
  number of [packages](https://www.idiap.ch/software/bob/packages) that implement
  tools for image, audio & video processing, machine learning & pattern
  recognition, and a lot more task specific packages.

  **Please visit our** [website](https://www.idiap.ch/software/bob) **for more**
  **information.**



  This package does nothing by itself. You should not need to install it, it will
  be installed as dependency of the utility package you use like
  [bob.bio.face](https://gitlab.idiap.ch/bob/bob.bio.face).



  The bob packages are developed using
  [idiap-devtools](https://gitlab.idiap.ch/software/idiap-devtools). Please refer
  to their documentation for release procedures.


pkgId: e88f2dd3afbee5009d79b3369c52d80c1698047492f6f6b5dbef807c7e88fb2a
name: python-bob.bio.face
arch: src
version: 8.0.1
epoch: 0
release: 1
summary: Tools for running face recognition experiments
url: https://pypi.org/project/bob.bio.face/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bob.bio.face-8.0.1-1.src.rpm
checksum_type: sha256
description:
  [![badge doc](https://img.shields.io/badge/docs-v8.0.1-orange.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.bio.face/v8.0.1/sphinx/index.html)
  [![badge pipeline](https://gitlab.idiap.ch/bob/bob.bio.face/badges/v8.0.1/pipeline.svg)](https://gitlab.idiap.ch/bob/bob.bio.face/commits/v8.0.1)
  [![badge coverage](https://gitlab.idiap.ch/bob/bob.bio.face/badges/v8.0.1/coverage.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.bio.face/v8.0.1/coverage/)
  [![badge gitlab](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/bob/bob.bio.face)



  This package is part of the signal-processing and machine learning toolbox
  [Bob](https://www.idiap.ch/software/bob).
  This package is part of the `bob.bio` packages, which allow to run
  comparable and reproducible biometric recognition experiments on publicly
  available datasets.

  This package contains functionality to run face recognition experiments.
  It is an extension to the
  [bob.bio.base](https://pypi.python.org/pypi/bob.bio.base) package, which
  provides the basic scripts.
  In this package, utilities that are specific for face recognition are
  contained, such as:

  * Image databases
  * Image preprocesors, including face detection and facial image alignment
  * Image feature extractors
  * Recognition algorithms based on image features



  Complete Bob's
  [installation instructions](https://www.idiap.ch/software/bob/install). Then,
  to install this package, run:

  ``` sh
  conda install bob.bio.face
  ```



  For questions or reporting issues to this software package, contact our
  development [mailing list](https://www.idiap.ch/software/bob/discuss).


pkgId: 5fd7fda24c1e965ee412c43afff576735dfc8048e2f9662f0447a2b32135bbf8
name: python-bob.learn.em
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Bindings for EM machines and trainers of Bob
url: https://pypi.org/project/bob.learn.em/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bob.learn.em-3.3.1-1.src.rpm
checksum_type: sha256
description:
  [![badge doc](https://img.shields.io/badge/docs-v3.3.1-orange.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.learn.em/v3.3.1/sphinx/index.html)
  [![badge pipeline](https://gitlab.idiap.ch/bob/bob.learn.em/badges/v3.3.1/pipeline.svg)](https://gitlab.idiap.ch/bob/bob.learn.em/commits/v3.3.1)
  [![badge coverage](https://gitlab.idiap.ch/bob/bob.learn.em/badges/v3.3.1/coverage.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.learn.em/v3.3.1/coverage)
  [![badge gitlab](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/bob/bob.learn.em)



  This package is part of the signal-processing and machine learning toolbox
  [Bob](https://www.idiap.ch/software/bob). It contains routines for learning
  probabilistic models via Expectation Maximization (EM).

  The EM algorithm is an iterative method that estimates parameters for
  statistical models, where the model depends on unobserved latent variables. The
  EM iteration alternates between performing an expectation (E) step, which
  creates a function for the expectation of the log-likelihood evaluated using
  the current estimate for the parameters, and a maximization (M) step, which
  computes parameters maximizing the expected log-likelihood found on the E step.
  These parameter-estimates are then used to determine the distribution of the
  latent variables in the next E step.

  The package includes the machine definition per se and a selection of different
  trainers for specialized purposes:

   - Maximum Likelihood (ML)
   - Maximum a Posteriori (MAP)
   - K-Means
   - Inter Session Variability Modelling (ISV)
   - Joint Factor Analysis (JFA)
   - Total Variability Modeling (iVectors)
   - Probabilistic Linear Discriminant Analysis (PLDA)
   - EM Principal Component Analysis (EM-PCA)




  Complete Bob's [installation](https://www.idiap.ch/software/bob/install)
  instructions. Then, to install this package, run:

  ``` sh
  conda install bob.learn.em
  ```




  For questions or reporting issues to this software package, contact our
  development [mailing list](https://www.idiap.ch/software/bob/discuss).


pkgId: 406c25ef32164a587329be76a5102bc6c88f4d2537d01be7170340f1fbfe30e3
name: python-bob.measure
arch: src
version: 6.1.1
epoch: 0
release: 1
summary: Evaluation metrics for Bob
url: https://pypi.org/project/bob.measure/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bob.measure-6.1.1-1.src.rpm
checksum_type: sha256
description:
  [![badge doc](https://img.shields.io/badge/docs-v6.1.1-orange.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.measure/v6.1.1/sphinx/index.html)
  [![badge pipeline](https://gitlab.idiap.ch/bob/bob.measure/badges/v6.1.1/pipeline.svg)](https://gitlab.idiap.ch/bob/bob.measure/commits/v6.1.1)
  [![badge coverage](https://gitlab.idiap.ch/bob/bob.measure/badges/v6.1.1/coverage.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.measure/v6.1.1/coverage/)
  [![badge gitlab](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/bob/bob.measure)



  This package is part of the signal-processing and machine learning toolbox
  [Bob](https://www.idiap.ch/software/bob). It contains common routines for
  assessing performance of machine learning experiments.



  Complete Bob's
  [installation instructions](https://www.idiap.ch/software/bob/install).

  Then, to install this package, run:

  ``` sh
  conda install bob.measure
  ```



  For questions or reporting issues to this software package, contact our
  development [mailing list](https://www.idiap.ch/software/bob/discuss).


pkgId: b21c9d1c04351ef81d7f84955c0721331ba8e42f961f021a27056ee38381b25a
name: python-bob.pad.base
arch: src
version: 6.0.1
epoch: 0
release: 1
summary: A framework for executing the chain of presentation attack detection (PAD) experiments
url: https://pypi.org/project/bob.pad.base/
rpm_license: GPLv3 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bob.pad.base-6.0.1-1.src.rpm
checksum_type: sha256
description:
  [![badge doc](https://img.shields.io/badge/docs-v6.0.1-orange.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.pad.base/v6.0.1/sphinx/index.html)
  [![badge pipeline](https://gitlab.idiap.ch/bob/bob.pad.base/badges/v6.0.1/pipeline.svg)](https://gitlab.idiap.ch/bob/bob.pad.base/commits/v6.0.1)
  [![badge coverage](https://gitlab.idiap.ch/bob/bob.pad.base/badges/v6.0.1/coverage.svg)](https://www.idiap.ch/software/bob/docs/bob/bob.pad.base/v6.0.1/coverage/)
  [![badge gitlab](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/bob/bob.pad.base)



  This package is part of the signal-processing and machine learning toolbox
  [Bob](https://www.idiap.ch/software/bob).
  This package is the base of the `bob.pad` family of packages, which allow to
  run comparable and reproducible presentation attack detection (PAD) experiments
  on publicly available databases.

  This package contains basic functionality to run PAD experiments.
  It provides a generic API for PAD including:

  * A database and its evaluation protocol
  * A data preprocessing algorithm
  * A feature extraction algorithm
  * A PAD algorithm

  All these steps of the PAD system are given as configuration files.
  All the algorithms are standardized on top of scikit-learn estimators.

  In this base package, only a core functionality is implemented. The specialized
  algorithms should be provided by other packages, which are usually in the
  `bob.pad` namespace, like
  [`bob.pad.face`](https://gitlab.idiap.ch/bob/bob.pad.face).



  Complete Bob's
  [installation instructions](https://www.idiap.ch/software/bob/install). Then,
  to install this package, run:
  ``` sh
  conda install bob.pad.base
  ```



  For questions or reporting issues to this software package, contact our
  development [mailing list](https://www.idiap.ch/software/bob/discuss).


pkgId: 4ddefd176bd9d34ed904bbb0ca03c6639a43a00804a238f62497441be4b9d2d1
name: python-bob3client
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Lightweight bob3 client utilities
url: https://pypi.org/project/bob3client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bob3client-0.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a python client for the bob3 API endpoints. It is lightweight utility to provide
  easier access to the API endpoints.



  ```bash
  pip install bob3client
  ```



  To authenticate against the API you must have a private RSA key file available. This key file
  is used to sign the JWT token that is used to authenticate against the API.

  Authentication works in such a way that you first register app in the workspace and provide
  permissions to it in bob3. There you will need to provide public key of the RSA key pair that
  you will use to sign the JWT token. There you also acquire app_id that you will use.

  To make easier authentication `bob3client` provides a function `get_auth_token` that will
  do all authentication job for you and return already a token that you can use to authenticate
  to bob3 API. You will not need to sign JWT token yourself or call `POST /auth` endpoint.

  ```python
  import bob3client






  token = bob3client.get_auth_token('workspace', 'app_id', 'private_rsa_key_path')



  import requests
  headers = {"Authorization": token}

  response = requests.get(bob3client.BOB3_PROD_URL + 'projects', headers=headers)
  print(response.json())
  ```

  To get API documentation fetch simply bob3client.BOB3_PROD_URL path in your favorite browser.


pkgId: ff2c18dc3504a68730148be90a6afec6e3ee054e2a0d30ca69dcd2d00c0aa97e
name: python-bobcat-miner
arch: src
version: 0.16.6
epoch: 0
release: 1
summary: Automate the Bobcat miner from the command line.
url: https://github.com/aidanmelen/bobcat-miner-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bobcat-miner-0.16.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/bobcat_miner.svg)](https://pypi.org/project/bobcat-miner/)
  [![Dockerhub](https://img.shields.io/docker/v/aidanmelen/bobcat?color=blue&label=docker%20build)](https://hub.docker.com/r/aidanmelen/bobcat)
  [![Release](https://github.com/aidanmelen/bobcat-miner-python/actions/workflows/release.yaml/badge.svg)](https://github.com/aidanmelen/bobcat-miner-python/actions/workflows/release.yaml)
  [![Tests](https://github.com/aidanmelen/bobcat-miner-python/actions/workflows/tests.yaml/badge.svg)](https://github.com/aidanmelen/bobcat-miner-python/actions/workflows/tests.yaml)
  [![Lint](https://github.com/aidanmelen/bobcat-miner-python/actions/workflows/lint.yaml/badge.svg)](https://github.com/aidanmelen/bobcat-miner-python/actions/workflows/lint.yaml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  Automatically *find*, *diagnose*, and *repair* the Bobcat miner!

  **Online**
  ```console
  $ bobcat autopilot
  ✅ Online Status: Online ⭐
  ✅ Sync Status: Synced (gap:-1) 💫
  ✅ Relay Status: Not Relayed ✨
  ✅ Network Status: Good 📶
  ✅ Temperature Status: Good (38°C) ☀️
  ```

  **Offline**
  ```console
  $ bobcat autopilot
  ❌ Online Status: Offline
  ❌ Bobcat Status: Down
  ⚠️ Rebooting Bobcat
  ✅ Reconnected to the Bobcat (fancy-awesome-bobcat)
  ⚠️ Resetting Bobcat
  ✅ Reconnected to the Bobcat (fancy-awesome-bobcat)
  ⚠️ Fastsyncing Bobcat
  ✅ Reconnected to the Bobcat (fancy-awesome-bobcat)
  ✅ Repair Status: Complete
  ✅ Relay Status: Not Relayed ✨
  ✅ Network Status: Good 📶
  ✅ Temperature Status: Good (38°C) ☀️
  ```

  or run with the official Docker image

  ```
  docker run --rm -it aidanmelen/bobcat autopilot
  ```

  ℹ️ Run `bobcat --help` to learn about the available sub-commands and options.





  ```
  pipx install bobcat-miner
  ```

  ℹ️ Please see this [guide](https://packaging.python.org/en/latest/guides/installing-stand-alone-command-line-tools/) for more information about installing stand alone command line tools with [pipx](https://pypa.github.io/pipx/).



  ```
  docker pull aidanmelen/bobcat
  ```



  Autopilot will automatically search and find your Bobcat. Setting the log-level to `DEBUG` will show more information about the search process.

  ```console
  $ bobcat -C DEBUG autopilot
  🐛 Searching for a bobcat in these networks: 192.168.0.0/24, 10.0.0.0/24, 172.16.0.0/24, 192.168.0.1/16, 10.0.0.1/16, 172.16.0.1/16
  🐛 Searching network: 192.168.0.0/24
  🐛 Connected to Bobcat: 192.168.0.10
  🐛 Found Bobcat: 192.168.0.10
  🐛 The Bobcat Autopilot is starting 🚀 🚀 🚀
  ...
  ```

  The search may take awhile depending on your Bobcat's IP address. However; this step can be skipped by specifying either the `--ip-address` or `--hostname` options.

  ```console
  $ bobcat --ip-address 192.168.0.10 -C DEBUG autopilot
  🐛 Connected to Bobcat: 192.168.0.10
  🐛 The Bobcat Autopilot is starting 🚀 🚀 🚀
  ...
  ```

  ℹ️ Please see the offical [bobcat instructions](https://bobcatminer.zendesk.com/hc/en-us/articles/4412905935131-How-to-Access-the-Diagnoser) to manually find the IP address.



  Use the `--dry-run` option to see what repair steps the `bobcat autopilot` would normally run

  ```console
  $ bobcat --dry-run autopilot
  ❌ Online Status: Offline
  ❌ Bobcat Status: Down
  ⚠️ Dry Run: Reboot Skipped
  ⚠️ Dry Run: Reset Skipped
  ⚠️ Dry Run: Fastsync Skipped
  ✅ Network Status: Good 📶
  ✅ Temperature Status: Good (38°C) ☀️
  ```



  Use the `--verbose` option to see detailed diagnostics

  ```console
  $ bobcat autopilot --verbose
  ...
  ❌ Bobcat Status: Down
  **Points to:** Miner's Docker Container

  **Why does this happen?**
  This can happen if your miner's Docker crashes. Sometimes losing power or internet connection during an OTA can cause a miner's Docker to crash. This can typically be fixed with a reboot or a reset, followed by a fast sync if your gap is >400. Fast Sync is recommended if your gap is >400 and your miner has been fully synced before.

  **What You Can Try:**
  1. First Try Reboot
  2. Try Reset
  3. Then Fastsync
  4. Make Sure Your Miner is Connected to the Internet. What color is your miner's LED?

  **What to provide customer support if unable to resolve:**
  1. If Possible, Screenshots of Your Diagnoser.
  2. Indicate Miner's LED Color
  3. Open Port 22, if Unable to Access the Diagnoser
  4. Provide Miner's IP Address
  5. Confirm Port 22 is Open (Include a Screenshot of this Page)

  **Troublesooting Guides:**
  - https://bobcatminer.zendesk.com/hc/en-us/articles/4413666097051-Status-Down-4413666097051-Status-Down-
  ...
  ```




  Monitor your Bobcat remotely by sending events to a Discord channel. No need for VPN or SSH agent setup!

  ```console
  $ bobcat --discord-webhook-url https://discord.com/api/webhooks/xxx autopilot
  ✅ Online Status: Online ⭐
  ✅ Sync Status: Synced (gap:0) 💫
  ⚠️ Relay Status: Relayed
  ✅ Network Status: Good 📶
  ❌ Temperature Status: Hot (78°C) 🌋
  ```

  and check the Discord channel

  <!-- <img src="https://raw.githubusercontent.com/aidanmelen/bobcat-miner-python/main/assets/bobcat-autopilot-discord-app.png" alt="drawing" style="width:500px;"/> -->
  <img src="https://raw.githubusercontent.com/aidanmelen/bobcat-miner-python/main/assets/bobcat-autopilot-discord-app.png" alt="drawing" width="300"/>

  ℹ️ Please see Discord's [Intro to Webhooks](https://support.discord.com/hc/en-us/articles/228383668-Intro-to-Webhooks) document for more information.



  Please see the [Bobcat SDK Docs](https://github.com/aidanmelen/bobcat-miner-python/blob/main/docs/bobcat_sdk.md) for more information.




  Please see the [Contributions Docs](https://github.com/aidanmelen/bobcat-miner-python/blob/main/docs/contributions.md) for more information. This document includes sections for Development, Test, and Release.



  Please see [No Witness's Troubleshooting Guide](https://www.nowitness.org/troubleshooting/) for more information.



  Donations are welcome and appreciated! :gift:

  [![HNT: 14HmckNU4WHDDtGH29FMqVENzZAYh5a9XRiLfY2AN6ghfHMvAuR](https://raw.githubusercontent.com/aidanmelen/bobcat-miner-python/main/assets/wallet.jpg)](https://explorer-v1.helium.com/accounts/14HmckNU4WHDDtGH29FMqVENzZAYh5a9XRiLfY2AN6ghfHMvAuR)

  HNT: [14HmckNU4WHDDtGH29FMqVENzZAYh5a9XRiLfY2AN6ghfHMvAuR](https://explorer-v1.helium.com/accounts/14HmckNU4WHDDtGH29FMqVENzZAYh5a9XRiLfY2AN6ghfHMvAuR)


pkgId: 3d014481bfba50e3c31a9060d1736f12cc7ec4a82d821ec2fc60fb8d78911793
name: python-bobcatpy
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Control and monitor your Bobcat miner
url: https://github.com/ardevd/bobcatpy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bobcatpy-2.1.2-1.src.rpm
checksum_type: sha256
description:
  An asyncio based Python library to interact with the Bobcat Helium miner diagnostics API.

  `bobcatpy` provides an alternative way to interact with the Bobcat diagnoser interface.




  `bobcatpy` is available through PyPi.

  ```
  pip install bobcatpy
  ```



  ```python
  from bobcatpy import Bobcat
  import asyncio

  async def main():
      b = Bobcat("10.10.21.70")

      status = await b.status_summary()
      print(status)
      await b.close_session()

  asyncio.run(main())
  ```


pkgId: d620d1e0db37ead646ade15d8b3efeb481fe138d908c7efc248141ab85ea4937
name: python-bobo
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Web application framework for the impatient
url: http://bobo.readthedocs.io
rpm_license: ZPL 2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bobo-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Bobo is a light-weight framework for creating WSGI web applications.
  Its goal is to be easy to use and remember.
  It addresses 2 problems:
  - Mapping URLs to objects
  - Calling objects to generate HTTP responses
  Bobo doesn't have a templating language, a database integration layer,
  or a number of other features that are better provided by WSGI
  middle-ware or application-specific libraries.
  Bobo builds on other frameworks, most notably WSGI and WebOb.
  To learn more. visit: http://bobo.digicool.com


pkgId: 2a9bb94aa520e6b72ddf051b2b916840e3a4ef391be7c1d0a4f5a0cf2859100e
name: python-bobotools
arch: src
version: 0.4.8.0
epoch: 0
release: 1
summary: bobotools
url: https://pypi.org/project/bobotools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bobotools-0.4.8.0-1.src.rpm
checksum_type: sha256
description:
  [![OSCS Status](https://www.oscs1024.com/platform/badge/bobo0810/bobotools.svg?size=small)](https://www.oscs1024.com/project/bobo0810/bobotools?ref=badge_small)
  - 收录到[PytorchNetHub](https://github.com/bobo0810/PytorchNetHub)



  ```bash
  pip install bobotools
  or
  pip install git+https://github.com/bobo0810/bobotools.git
  ```




  |  方法   | 功能  |
  |  ----  | ----  |
  | get_model_info  | 获取模型信息(模型大小、计算量、参数量、前向推理耗时等) |
  | vis_tensor  | 可视化tensor|
  | vis_cam  | 可视化注意力图|



  |  方法   | 功能  |
  |  ----  | ----  |
  | download_url  | 多进程下载URL图像|
  | filter_md5  | 对输入的图像列表，互相去重，返回重复图像列表|
  | verify_integrity  | 对输入的图像列表，验证完整性，返回错误图像列表|
  | plot_yolo  | 可视化yolo结果|





  |  方法   | 功能  |
  |  ----  | ----  |
  | read_lines  | 批量读取txt，支持指定分隔符 |
  | write_lines  | 批量写入,保存为txt |


  |  方法   | 功能  |
  |  ----  | ----  |
  | chunk_N  | 列表均分为N块 |
  | chunk_per| 列表分块，每块为指定长度M |




  - [Python打包](https://www.jianshu.com/p/9a5e7c935273)


pkgId: edc48cc440eeec7e7a9bf4a49433cce90530aab97c6cffab77c87b77209e0128
name: python-bobtail
arch: src
version: 0.0.28
epoch: 0
release: 1
summary: A little Python http framework
url: https://github.com/joegasewicz/bobtail
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bobtail-0.0.28-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/joegasewicz/bobtail/actions/workflows/python-package.yml/badge.svg)](https://github.com/joegasewicz/bobtail/actions/workflows/python-package.yml)
  [![Upload Python Package](https://github.com/joegasewicz/bobtail/actions/workflows/python-publish.yml/badge.svg)](https://github.com/joegasewicz/bobtail/actions/workflows/python-publish.yml)
  [![GitHub license](https://img.shields.io/github/license/joegasewicz/bobtail)](https://github.com/joegasewicz/bobtail/blob/master/LICENSE.md)

  [//]: # (![PyPI - Python Version]&#40;https://img.shields.io/pypi/pyversions/bobtail&#41;)

  ![Bobtail](bobtail.png?raw=true "Bobtail")
  A little Python http framework

  ⚠️ *Ready to use in `v0.1.0`, production ready in `v1.0.0`*

  Read the [docs](https://bobtail.readthedocs.io/en/latest/)


  ```
  pipenv install bobtail
  pipenv install gunicorn
  ```


  An example of the smallest Bobtail app
  ```python
  from bobtail import BobTail, AbstractRoute, Request, Response

  class Images:

      def get(self, req, res):
          res.set_body({id: 1})

  routes = [
      (Images(), "/images")
  ]

  app = BobTail(routes=routes)
  ```


  ```
  pipenv run  gunicorn api:app
  ```

  To define port, static directory, template directory etc. you can
  create a concrete version of the BaseOptions abstract class. See the [docs](https://bobtail.readthedocs.io/en/latest/options.html) for more info.
  ```python
  from bobtail.options import BaseOptions

  class Options(BaseOptions):
      PORT = 8001

  app = Bobtail(Options)
  ```

  Bobtail middleware


  ```python
  from bobtail_logger import BobtailLogger

  app = Bobtail(routes=routes)


  app.use(BobtailLogger())
  ```

  Middleware currently available
  - [bobtail-cors](https://github.com/joegasewicz/bobtail-cors)
  - [bobtail-logger](https://github.com/joegasewicz/bobtail-logger)
  - [bobtail-upload](https://github.com/joegasewicz/bobtail-upload)
  - [bobtail-jinja2](https://github.com/joegasewicz/bobtail-jinja2)


  Creating custom middleware example. A Middleware object must implement `AbstractMiddleware`.

  ```python
  from bobtail import Request, Response
  from bobtail.middleware import AbstractMiddleware, Tail

  class BobtailCors(AbstractMiddleware):

      def run(self, req: Request, res: Response, tail: Tail) -> None:
          res.set_headers({
              "Access-Control-Allow-Origin": "*",
          })
          tail(req, res)
  ```


  Bobtail does not ship with a templating engine directly, but you can install and use
  a templating engine with ease via middleware.

  Currently, there is middleware support for Jinja2, for example
  ```python
  from bobtail_jinja2 import BobtailJinja2

  blog = BobTail(routes=routes)
  blog.use(BobtailJinja2(template_dir="templates"))
  ```
  Then to use in a request handler
  ```python
  def get(self, req: Request, res: Response) -> None:
      res.jinja2.render(res, "layout.jinja2", data={"name": "joe"})
  ```


  You can set the headers with the `Response` object's `set_headers` method. The default headers
  are `Content-Type: application/json`.
  ```python
  class Images:

      def get(self, req, res):
          res.set_headers({"Content-type": "text/plain"})

  ```


  You can set the status with the `Response` object's `set_status` method. The default status
  is always set to `200` if there are no errors.
  ```python
  class Images:

      def get(self, req, res):
          res.set_status(202)

  ```



  You can specify the type of `Request` arguments using curly braces & within the name & type seperated
  by a colon, for example:
  ```
  /images/{id:int}/{name:str}/{is_raining:bool}
  ```
  To access request arguments inside a route handler, use the `Request` object's `get_arg` method, for example:
  ```python
  def get(self, req, res):
      id = req.get_args("id") # int
      name = req.get_args("name") # str
      is_raining = req.get_args("is_raining") # bool
  ```


  - JSON
   ```python

  req.get_json()
  ```
  - Plain Text
   ```python

  req.get_body()
  ```
  - Urlencoded form data
   ```python

  req.get_form_data()
  ```
  - Multipart form data
   ```python

  req.get_multipart_data()
  ```

  The `Request` object provides methods to easily get form values. By default, if a form value
  doesn't exist, then either `FormDataError` or `MultipartFormDataError` exceptions will be raised.

  - Get Form Field Value
  ```python
  from bobtail.exceptions import FormDataError
  try:
      email = req.form.get_field("email")
  except FormDataError:
      pass # handle no form value
  ```

  - Get Multipart Form Field Value
  ```python
  from bobtail.exceptions import MultipartFormDataError
  try:
      email = req.multipart.get_field("email")
  except MultipartFormDataError:
      pass # handle no multipart form value
  ```

  - Get Multipart Form File Value
  ```python
  from bobtail.exceptions import MultipartFormDataError
  try:
      email = req.multipart.get_file("image")
  except MultipartFormDataError:
      pass # handle no multipart form value
  ```

  - Get Multipart Form File Name
  ```python
  from bobtail.exceptions import MultipartFormDataError
  try:
      email = req.multipart.get_name("image")
  except MultipartFormDataError:
      pass # handle no multipart form value
  ```

  - Get Multipart Form File Data
  ```python
  from bobtail.exceptions import MultipartFormDataError
  try:
      email = req.multipart.get_data("image")
  except MultipartFormDataError:
      pass # handle no multipart form value
  ```

  - Get Multipart Form File Mimetype
  ```python
  from bobtail.exceptions import MultipartFormDataError
  try:
      email = req.multipart.get_mimetype("image")
  except MultipartFormDataError:
      pass # handle no multipart form value
  ```

  This method returns a dict og query params where the key
  is on the left side of the `=` sign & the value is pn the right.
  For example:
  ```python

  def get(self, req: Request, res: Response):
      result = req.get_params() # {"name": "joe", "age": "48"}
  ```


  To declare a static route postfix a `*` to the route's path::
  ```python
  from bobtail import BobTail AbstractRoute, BaseOptions
  from bobtail_jinja2 import BobtailJinja2

  routes = [
      (Static(), "/static/*"),
  ]

  class Options(BaseOptions):
      STATIC_DIR = "app/static"
      TEMPLATE_DIR = "app/templates"

  blog = BobTail(routes=routes, options=Options())
  blog.use(BobtailJinja2(template_dir="app/templates"))
  ```
  Calling `set_static` from within a route method will render a static
  file such as a .css, .js or a media type file. The :class:`~BaseOptions`
  class sets the `STATIC_DIR` directory.
  ```python

      class Static(AbstractRoute):
          def get(self, req: Request, res: Response) -> None:
              res.set_static(req.path)
  ```
  You can set the static file path using the :class:`~BaseOptions`.
  ```python

  class Options(BaseOptions):
      STATIC_DIR = "/static"


  class Static(AbstractRoute):
      def get(self, req: Request, res: Response) -> None:
          res.set_static(req.path)
  ```
  By default, `STATIC_DIR` is set to `/static`, if your static file is nested
  within a Python package, for example `app/static` the set as `STATIC_DIR = "app/static"`

  To render an image from within a Jinja2 template include the full path including the
  static directory name or path. For example::
  ```html
  <!-- if STATIC_DIR = "/static" -->
  <body>
      <img src="/static/imgs/cat1.jpg" />
  </body>
  ```
  OR without the first forward slash::
  ```html
  <body>
      <img src="static/imgs/cat1.jpg" />
  </body>
  ```

  If you prefer to organise your routes in a more OOP approach, you can implement the
  `AbstractRoute` abstract class. It's especially useful when using an IDE like Pycharm
  where the IDE will generate automatically all the require methods.
  ```python
  from bobtail import AbstractRoute, Request, Response



  class Images(AbstractRoute):
      pass
  ```
  Which will generate the following:

  ```python
  from bobtail import AbstractRoute, Request, Response


  class Images(AbstractRoute):
      def get(self, req: Request, res: Response):
          pass

      def post(self, req: Request, res: Response):
          pass

      def put(self, req: Request, res: Response):
          pass

      def delete(self, req: Request, res: Response):
          pass

  ```


pkgId: 98004e40d63cb909cd34f9782769dba473fe730a4cb7a5f429562ebc8b74666f
name: python-bocd
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Bayesian online changepoint detection
url: https://github.com/y-bar/bocd
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bocd-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/y-bar/bocd.svg?branch=master)](https://travis-ci.com/y-bar/bocd)

  Bayesian Online Changepoint Detection in Python.



  The algorithm is based on the following paper

  Adams, Ryan Prescott, and David JC MacKay. "Bayesian online changepoint detection."
  arXiv preprint [arXiv:0710.3742](https://arxiv.org/abs/0710.3742) (2007).



  Example jupyter notebooks are located [here](https://github.com/y-bar/bocd/tree/master/notebook)



  ```bash
  $ pip install bocd
  ```


pkgId: 06850e09fdbfa00d725810841cab2fa4f724960b6977b2443dc6d3dce995f047
name: python-bocfx
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Easy API to get foreign exchange rate from Bank of China.
url: https://github.com/bobleer/bocfx
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bocfx-0.8.1-1.src.rpm
checksum_type: sha256
description:
  An easy-to-use python package for getting foreign exchange rate from Bank of China (BOC).
  一个帮你快速获取中国银行外汇牌价的 Python 爬虫（也可作外汇牌价实时查询API)。
  Author: [**Bob Lee**](https://boblee.cn)

  <br>




  * [x] **Multithreading 多线程**
  * [x] **As a command-line application 支持命令行应用模式**
  * [x] **As a python module 支持模块导入模式（import到你自己的项目里就能作API了）**
  * [x] **Foreign exchange selection 支持多种外汇币种同时输出（默认是英、欧、美、加、澳）**
  * [x] **Foreign exchange quotation filter 支持外汇牌价种类同时输出（买入、卖出、现钞、现汇、中行折算价）**
  * [x] **Date selection (Realtime/History) 支持仅输出最新牌价 或 输出指定时间段内全部牌价变动**
  * [x] **Line graph generation 支持生成历史波动曲线**
  * [x] **.csv generation 支持导出csv格式表格文件**
  * [x] **Set output path 支持导出到指定路径**
  * [x] **Show or close loading bar 支持显示或关闭进度条**
  * [x] **Export to database 支持导出到数据库（可使用Pandas的df.to_sql()）**

  <br>




  - [Installation 安装](#installation)
  - [Basic Usage 基本用法](#basic-usage)
  	- [As a command-line application 作为命令行程序使用](#as-command-line-application)
  	- [As a python module 作为API使用](#as-python-module)
  - [Advanced Usage 进阶用法](#advanced-usage)
  	- [As a command-line application 作为命令行程序使用](#as-command-line-application-1)
  		- [Example](#example)
  	- [As a python module 作为API使用](#as-python-module-1)
  		- [Example](#example-1)
  - [Option and parameter 参数选择](#option-and-parameter)
  	- [Option 1 `-f`/`--fx` 外汇种类](#option-1--f--fx)
  		- [Common foreign currency:](#common-foreign-currency)
  		- [Example](#example-2)
  	- [Option 2 `-s`/`--sort` 牌价种类](#option-2--s--sort)
  		- [Example](#example-3)
  	- [Option 3 `-t`/`--time` 时间、时间段](#option-3--t--time)
  	- [Option 4 `-p`/`--plot` 画图](#option-4--p--plot)
  	- [Option 5 `-c`/`--csv` 导出csv表格](#option-5--c--csv)
  	- [Option 6 `-o`/`--op` 导出文件路径设置](#option-6--o--op)
  	- [Option 7 `-b`/`--bar` 开启进度条显示](#option-7--b--bar)
  - [Web API (temporary demo)](#web-api-temporary-demo)
  - [Limitation 局限性](#limitation)
  - [MIT Licence](#mit-licence)
  <br>




  Generally, one line command can perfect installation.
  ```
  pip3 install bocfx
  ```
  If your `pip` links python3, please use `pip install bocfx` to install bocfx.
  **REMEMBER**, Bocfx may not support python2.
  <br>
  <br>



  <br>




  ```
  ❯ bocfx


  +-----+--------+--------+--------+--------+----------+---------------------+
  |  5  | SE_BID | BN_BID | SE_ASK | BN_ASK | BOC_CONV |         Time        |
  +-----+--------+--------+--------+--------+----------+---------------------+
  | GBP | 873.01 | 845.88 | 879.44 | 883.32 |  874.54  | 2023-05-23 23:09:35 |
  | EUR | 757.61 | 734.07 | 763.19 | 765.65 |  760.31  | 2023-05-23 23:09:35 |
  | USD | 703.77 | 698.05 | 706.76 | 706.76 |  703.26  | 2023-05-23 23:09:35 |
  | CAD | 520.43 |  504   | 524.27 | 526.58 |  520.83  | 2023-05-23 23:09:35 |
  | AUD | 465.18 | 450.73 | 468.6  | 470.68 |  467.72  | 2023-05-23 23:09:35 |
  +-----+--------+--------+--------+--------+----------+---------------------+
  (SE = Spot Exchange, BN = Banknote)
  ```

  ```
  ❯ bocfx -f USD


  +-----+--------+--------+--------+--------+----------+---------------------+
  |  1  | SE_BID | BN_BID | SE_ASK | BN_ASK | BOC_CONV |         Time        |
  +-----+--------+--------+--------+--------+----------+---------------------+
  | USD | 703.77 | 698.05 | 706.76 | 706.76 |  703.26  | 2023-05-23 23:25:12 |
  +-----+--------+--------+--------+--------+----------+---------------------+
  (SE = Spot Exchange, BN = Banknote)
  ```

  <br>
  <br>




  ```
  >>> from bocfx import bocfx

  >>> output = bocfx('GBP,USD','SE,ASK') # 选择了英镑和美元，现汇卖出价
  >>> output # The latest foreign exchange rate | 英镑和美元，现汇卖出价 (最新的牌价)
  ['879.22', '706.76']
  ```
  <br>
  <br>



  <br>




  `-f` | 可选外汇 | FX selection
  `-s` | 可选牌价 | Quotation types selection
  `-t` | 可选时间 | Time / Period selection
  `-p` | 输出波动图 | Output plot
  `-c` | 输出csv | Output csv table
  `-o` | 指定输出路径 | Set output path

  ```Bash
  bocfx [-f|--fx] [-s|--sort] [-t|--time] (-p|--plot) (-c|--csv) {-o|--op}
  ```
  <br>
  <br>



  ```
  ❯ bocfx -f GBP,USD,AUD -s ASK -t 30 -p -c -o '~/desktop/output'
  100%|█████████████████████████████████████████████| 3/3 [00:03<00:00,  1.08s/it]
  100%|████████████████████████████████████████| 199/199 [00:00<00:00, 422.62it/s]

  +-----+--------+--------+---------------------+
  |  3  | SE_ASK | BN_ASK |         Time        |
  +-----+--------+--------+---------------------+
  | GBP | 880.27 | 882.41 | 2019-02-24 10:30:00 |
  | USD | 673.08 | 673.08 | 2019-02-24 10:30:00 |
  | AUD | 480.65 | 481.82 | 2019-02-24 10:30:00 |
  | GBP | 880.27 | 882.41 | 2019-02-24 05:30:00 |
  | USD | 673.08 | 673.08 | 2019-02-24 05:30:00 |
  | AUD | 480.65 | 481.82 | 2019-02-24 05:30:00 |
  ...
  | GBP | 889.64 | 891.8  | 2019-01-25 00:00:05 |
  | USD | 680.4  | 680.4  | 2019-01-25 00:00:05 |
  | AUD | 484.37 | 485.56 | 2019-01-25 00:00:05 |
  +-----+--------+--------+---------------------+
  (SE = Spot Exchange, BN = Banknote)

  .csv has already saved to /Users/bob/desktop/output/[GBP+USD+AUD]SE_ASK+BN_ASK_2019-01-25_2019-02-24.csv

  Plot has already saved to /Users/bob/desktop/output/[GBP+USD+AUD]SE_ASK+BN_ASK_2019-01-25_2019-02-24.png
  ```
  ![](https://github.com/bobleer/bocfx/raw/master/images/%5BGBP%2BUSD%2BAUD%5DSE_ASK%2BBN_ASK_2019-01-25_2019-02-24.png)
  <br>
  <br>



  ```python
  from bocfx import bocfx

  bocfx(FX=0, sort=0, time=-1, plot=0, csv=0, pt=0, op='~/bocfx_output')
  ```
  <br>
  <br>



  ```
  >>> from bocfx import bocfx




  >>> example01 = bocfx('GBP,USD','SE',1)
  100%|█████████████████████████████████████████████| 2/2 [00:01<00:00,  1.49it/s]

  >>> type(example01)
  <class 'list'>

  >>> print(example01)
  [[2, 'SE_BID', 'SE_ASK', 'Time'], ['USD', '669.74', '672.58', '2019-02-25 09:25:23'], ['GBP', '874.18', '880.62', '2019-02-25 09:25:13'], ... , ['GBP', '873.83', '880.27', '2019-02-24 00:00:05'], ['USD', '670.24', '673.08', '2019-02-24 00:00:05']]
  ```

  <br>

  ```
  >>> from bocfx import bocfx




  >>> example02 = bocfx('GBP,USD','SE','2018-08-01,2018-08-02',1,1,0,op='~/desktop/example/')
  100%|█████████████████████████████████████████████| 2/2 [00:02<00:00,  1.05it/s]
  100%|██████████████████████████████████████████| 26/26 [00:00<00:00, 134.46it/s]

  .csv has already saved to /Users/bob/desktop/example/[GBP+USD]SE_BID+SE_ASK_2018-08-01_2018-08-02.csv

  Plot has already saved to /Users/bob/desktop/example/[GBP+USD]SE_BID+SE_ASK_2018-08-01_2018-08-02.png

  >>> type(example02)
  <class 'list'>

  >>> print(example02)
  [[2, 'SE_BID', 'SE_ASK', 'Time'], ['GBP', '888.85', '895.4', '2018-08-02 23:19:36'], ['USD', '683.01', '685.91', '2018-08-02 23:19:36'], ... , ['GBP', '891.33', '897.89', '2018-08-01 00:00:05'], ['USD', '680.22', '683.1', '2018-08-01 00:00:05']]
  ```

  ![](https://github.com/bobleer/bocfx/raw/master/images/%5BGBP%2BUSD%5DSE_BID%2BSE_ASK_2018-08-01_2018-08-02.png)
  <br>
  <br>



  <br>



  `-f`/`--fx` is the BOC foreign excahnge selector. This opinion supports **multi-parameter**.

  `,` is the separator of each parameter, e.g. `GBP,USD`
  <br>
  <br>



  FX | ISO Code | Full Name | Alias
  :-|:-|:-|:-
  `英镑` | `GBP` | Great Britain Pound | `UK`
  `港币` | `HKD` | Hong Kong Dollar | `HK`
  `美元` | `USD` | United States Dollar | `US`/`USA`
  `瑞士法郎` | `CHF` | Swiss Franc |
  `德国马克` | `DEM` | Deutsche Mark |
  `法国法郎` | `FRF` | French Franc | `FF`
  `新加坡元` | `SGD` | Singapore Dollar |
  `瑞典克朗` | `SEK` | Swedish Krona |
  `丹麦克朗` | `DKK` | Danish Krone |
  `挪威克朗` | `NOK` | Norwegian Krone |
  `日元` | `JPY` | Japanese Yen | `JP`
  `加拿大元` | `CAD` | Canadian Dollar | `CA`
  `澳大利亚元` | `AUD` | Australian Dollar | `AU`
  `欧元` | `EUR` | Euro | `EU`
  `澳门元` | `MOP` | Macao Pataca | `MO`
  `菲律宾比索` | `PHP` | Philippine Peso |
  `泰国铢` | `THB` | Thai Baht |
  `新西兰元` | `NZD` | New Zealand Dollar | `KIWI`
  `韩国元` | `WON` | South Korean Won | `SK`
  `卢布` | `RUB` | Russian Ruble | `RU`
  `林吉特` | `MYR` | Malaysia Ringgit | `SEN`
  `新台币` | `NTD` | New Taiwan Dollar | `TW`
  `西班牙比塞塔` | `ESP` | Spain Peseta |
  `意大利里拉` | `ITL` | Italian Lira |
  `荷兰盾` | `ANG` | Nederlandse Gulden |
  `比利时法郎` | `BEF` | Belgian Franc |
  `芬兰马克` | `FIM` | Finnish Mark |
  `印度卢比` | `INR` | Indian Rupee |
  `印尼卢比` | `IDR` | Indonesian Rupee |
  `巴西里亚尔` | `BRL` | Brasil Rial |
  `阿联酋迪拉姆` | `AED` | United Arab Emirates Dirham |
  `南非兰特` | `ZAF` | South African Rand |
  `沙特里亚尔` | `SAR` | Saudi Arabian Riyal |
  `土耳其里拉` | `TRY` | Yeni Türk Lirası | `YTL`

  FX, ISO and Alias can be used as values of this option, e.g. `英镑`, `GBP`, `UK` are all correct.
  This parameter is case-insensitive, e.g. `GBP`, `gBp`, `UK`, `uk` will get same output.
  If not setting this parameter, the default value of parameter will be `GBP, EUR, USD, CAD, AUD`.
  <br>
  <br>



  ```
  ~
  ❯ bocfx
  100%|████████████████████████████████████████████| 5/5 [00:00<00:00, 612.38it/s]

  +-----+--------+--------+--------+--------+---------------------+
  |  5  | SE_BID | BN_BID | SE_ASK | BN_ASK |         Time        |
  +-----+--------+--------+--------+--------+---------------------+
  | GBP | 874.37 | 847.2  | 880.81 | 882.95 | 2019-02-25 07:28:17 |
  | EUR | 759.05 | 735.47 | 764.65 | 766.35 | 2019-02-25 07:28:17 |
  | USD | 670.24 | 664.79 | 673.08 | 673.08 | 2019-02-25 07:28:17 |
  | CAD | 509.47 | 493.39 | 513.23 | 514.47 | 2019-02-25 07:28:17 |
  | AUD | 478.68 | 463.81 | 482.21 | 483.38 | 2019-02-25 07:28:17 |
  +-----+--------+--------+--------+--------+---------------------+
  (SE = Spot Exchange, BN = Banknote)

  ~
  ❯ bocfx -f GBP,USD
  100%|███████████████████████████████████████████| 2/2 [00:00<00:00, 1818.08it/s]

  +-----+--------+--------+--------+--------+---------------------+
  |  2  | SE_BID | BN_BID | SE_ASK | BN_ASK |         Time        |
  +-----+--------+--------+--------+--------+---------------------+
  | GBP | 874.37 | 847.2  | 880.81 | 882.95 | 2019-02-25 07:28:17 |
  | USD | 670.24 | 664.79 | 673.08 | 673.08 | 2019-02-25 07:28:17 |
  +-----+--------+--------+--------+--------+---------------------+
  (SE = Spot Exchange, BN = Banknote)
  ```
  <br>
  <br>




  `-s`/`--sort` is the filter of quotation types. This opinion supports **multi-parameter**.

  `,` is the separator of each parameter.

  `-s`/`--sort` | `SE` Spot Exchange 现汇价 | `BN` Banknote 现钞价
   :-|:-|:-
   `BID` Bid Price 买入价 | `SE,BID` SE_BID | `BN,BID` BN_BID
   `ASK` Ask Price 卖出价 | `SE,ASK` SE_ASK | `BN,ASK` BN_ASK

  If not using this option, the default output will include all four sorts.
  <br>
  <br>



  ```
  ~
  ❯ bocfx -f GBP,USD -s ASK
  100%|████████████████████████████████████████████| 2/2 [00:00<00:00, 443.63it/s]

  +-----+--------+--------+---------------------+
  |  2  | SE_ASK | BN_ASK |         Time        |
  +-----+--------+--------+---------------------+
  | GBP | 880.81 | 882.95 | 2019-02-25 07:28:17 |
  | USD | 673.08 | 673.08 | 2019-02-25 08:35:54 |
  +-----+--------+--------+---------------------+
  (SE = Spot Exchange, BN = Banknote)

  ~
  ❯ bocfx -f GBP,USD -s SE,BID
  100%|████████████████████████████████████████████| 2/2 [00:00<00:00, 443.26it/s]

  +-----+--------+---------------------+
  |  2  | SE_BID |         Time        |
  +-----+--------+---------------------+
  | GBP | 874.57 | 2019-02-25 08:35:54 |
  | USD | 670.24 | 2019-02-25 08:35:54 |
  +-----+--------+---------------------+
  (SE = Spot Exchange, BN = Banknote)
  ```
  <br>
  <br>




  `-t`/`--time` can filter the date of foreign exchange quotation.

  There are 3 ways to write parameter.

   No. | Example | Definition | 定义
   :-|:-|:-|:-
   1 | `6` | Get data from 6 days ago to today | 6 天之内的全部历史价格
   2 | `2019-02-20` | Get data from 2019-02-20 to today | 选定时间到今天的全部历史价格
   3 | `2019-02-20,2019-02-21` | Get data from 2019-02-20 to 2019-02-21 | 选定时间范围内全部历史价格

  If not using this option, **only one price (the latest quotation price)** will be output.
  <br>
  <br>




  Using `-p`/`--plot` can generate a line graph with .png format.

  The default output path is `~/bocfx_output/`
  <br>
  <br>
  <br>




  Using `-c`/`--csv` can output data in .csv format.

  The default output path is `~/bocfx_output/`
  <br>
  <br>
  <br>




  Using `-o`/`--op` can change default output path.

  Example: `-o '~/desktop/example/'`
  <br>
  <br>
  <br>




  Using `-b`/`--bar` can show loading bar while the tasks are running.
  <br>
  <br>
  <br>



  ***HTTP GET:*** http://sh.boblee.cn:8080/apis/bocfx?FX=GBP,USD&sort=SE&time=&format=json

  Parameter | Examples
  :-|:-
  FX= | ` (Blank = GBP,EUR,USD,CAD,AUD)`, `GBP`, `GBP,USD,AUD`
  sort= | ` (Blank = ALL four types)`, `SE`, `BN`, `ASK`, `BID`, `SE,ASK`, `SE,BID`, `BN,ASK`, `BN,BID`
  time= | ` (Blank = The latest record)`, `1`, `2020-03-07`, `2020-03-07,2020-03-14`
  format= | ` (Blank = json)`, `json`, `csv`, `original`

  Description of each parameter can be found .
  每个参数的含义可参见上方的介绍.

  <br>





  This package is no-database design.

  All data are captured from http://srh.bankofchina.com/search/whpj/search.jsp in real time.

  **Thus, the speed of spider will be strongly influenced by the connectation quality!**
  **本脚本会受 中国银行官网接口速度 的影响！**
  <br>
  <br>
  <br>



  Copyright (c) 2019 The Python Packaging Authority

  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.
  <br>


