# packages

pkgId: 87b59e0309c858a00d6fd76f3cd49e3bfaddb9066de1f89970368ffebb2ace6a
name: python-bioversions
arch: src
version: 0.5.511
epoch: 0
release: 1
summary: What's the current version for each biological database?
url: https://github.com/biopragmatics/bioversions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioversions-0.5.511-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/biopragmatics/bioversions/raw/main/docs/source/logo.png" height="150">
  </p>

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

  <p align="center">
      <a href="https://pypi.org/project/bioversions">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/bioversions" />
      </a>
      <a href="https://pypi.org/project/bioversions">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/bioversions" />
      </a>
      <a href="https://github.com/biopragmatics/bioversions/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/bioversions" />
      </a>
      <a href="https://zenodo.org/badge/latestdoi/318852276">
          <img src="https://zenodo.org/badge/318852276.svg" alt="DOI" />
      </a>
      <a href="https://github.com/psf/black">
          <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
      </a>
      <a href="https://github.com/biopragmatics/bioregistry"$>
          <img alt="Powered by the Bioregistry" src="https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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" />
      </a>
  </p>

  What's the current version for each biological database?

  A daily updated static listing of all current versions (that are incorporated) can be found at
  https://biopragmatics.github.io/bioversions.



  ```bash
  $ pip install bioversions
  ```



  ```python
  import bioversions

  assert bioversions.get_version('biogrid') == '4.2.192', 'This was true on Dec 5th, 2020!'


  bioversion = bioversions.resolve('biogrid')
  assert bioversion.version == '4.2.192'
  ```

  By default, the results are cached and only refreshed once per day with the help
  of [`cachier`](https://github.com/shaypal5/cachier). The cache is stored in `~/.data/bioversions`. The cache location
  can be overridden by setting the
  `BIOVERSIONS_HOME` environment variable via [`pystow`](https://github.com/cthoyt/pystow).



  While https://biopragmatics.github.io/bioversions provides a daily updated static listing of the database, you can run a
  dynamic version with an API from your shell with:

  ```bash
  $ bioversions web
  ```

  Options can be listed with `bioversions web --help`.

  You can navigate to http://localhost:5000 to see all versions as HTML or programmatically resolve given databases with
  the
  `http://localhost:5000/database/<name>` endpoint like in the following:

  ```python
  import requests

  res = requests.get('http://localhost:5000/database/biogrid').json()
  assert res['success']
  assert res['result']['name'] == 'BioGRID'
  assert res['result']['version'] == '4.2.192', 'This was true on Dec 5th, 2020!'
  ```



  You can use `bioversions get` to incorporate the latest versions in your shell scripts or REPL usage like in:

  ```bash
  $ wget "https://downloads.thebiogrid.org/Download/BioGRID/Release-Archive/BIOGRID-$(bioversions get biogrid)/BIOGRID-ALL-$(bioversions get biogrid).mitab.zip"
  ```



  To add more databases to the list, you can create a new submodule of
  `bioversions.sources` and extend the `bioversions.utils.Getter` class to identify the most recent version for your
  target database. See
  `bioversions.sources.biogrid` as an example.





  Code is licensed under the MIT License.



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



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


pkgId: e4b09a9788e249e529483979143115f4590527ff6ca0b9a982f46eb77036ae67
name: python-bioversions
arch: src
version: 0.5.557
epoch: 0
release: 1
summary: Get the current version for biological databases
url: https://github.com/biopragmatics/bioversions
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bioversions-0.5.557-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/biopragmatics/bioversions/raw/main/docs/source/logo.png" height="150">
  </p>

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

  <p align="center">
      <a href="https://github.com/biopragmatics/bioversions/actions/workflows/tests.yml">
          <img alt="Tests" src="https://github.com/biopragmatics/bioversions/actions/workflows/tests.yml/badge.svg" /></a>
      <a href="https://pypi.org/project/bioversions">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/bioversions" /></a>
      <a href="https://pypi.org/project/bioversions">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/bioversions" /></a>
      <a href="https://github.com/biopragmatics/bioversions/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/bioversions" /></a>
      <a href='https://bioversions.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/bioversions/badge/?version=latest' alt='Documentation Status' /></a>
      <a href="https://codecov.io/gh/biopragmatics/bioversions/branch/main">
          <img src="https://codecov.io/gh/biopragmatics/bioversions/branch/main/graph/badge.svg" alt="Codecov status" /></a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-snekpack-blue" /></a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;"></a>
      <a href="https://github.com/biopragmatics/bioversions/blob/main/.github/CODE_OF_CONDUCT.md">
          <img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"/></a>
      <a href="https://zenodo.org/badge/latestdoi/318852276">
          <img src="https://zenodo.org/badge/318852276.svg" alt="DOI"></a>
      <a href="https://github.com/biopragmatics/bioregistry">
          <img alt="Powered by the Bioregistry" src="https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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" /></a>
  </p>

  What's the current version for each biological database?

  A daily updated static listing of all current versions (that are incorporated) can be found at
  https://biopragmatics.github.io/bioversions.



  ```python
  import bioversions

  assert bioversions.get_version('biogrid') == '4.2.192', 'This was true on Dec 5th, 2020!'


  bioversion = bioversions.resolve('biogrid')
  assert bioversion.version == '4.2.192'
  ```

  By default, the results are cached and only refreshed once per day with the help
  of [`cachier`](https://github.com/shaypal5/cachier). The cache is stored in `~/.data/bioversions`. The cache location
  can be overridden by setting the
  `BIOVERSIONS_HOME` environment variable via [`pystow`](https://github.com/cthoyt/pystow).



  While https://biopragmatics.github.io/bioversions provides a daily updated static listing of the database, you can run a
  dynamic version with an API from your shell with:

  ```bash
  $ bioversions web
  ```

  Options can be listed with `bioversions web --help`.

  You can navigate to http://localhost:5000 to see all versions as HTML or programmatically resolve given databases with
  the
  `http://localhost:5000/database/<name>` endpoint like in the following:

  ```python
  import requests

  res = requests.get('http://localhost:5000/database/biogrid').json()
  assert res['success']
  assert res['result']['name'] == 'BioGRID'
  assert res['result']['version'] == '4.2.192', 'This was true on Dec 5th, 2020!'
  ```



  You can use `bioversions get` to incorporate the latest versions in your shell scripts or REPL usage like in:

  ```bash
  $ wget "https://downloads.thebiogrid.org/Download/BioGRID/Release-Archive/BIOGRID-$(bioversions get biogrid)/BIOGRID-ALL-$(bioversions get biogrid).mitab.zip"
  ```



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

  ```console
  python3 -m pip install bioversions
  ```

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

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



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

  To add more databases to the list, you can create a new submodule of
  `bioversions.sources` and extend the `bioversions.utils.Getter` class to identify the most recent version for your
  target database. See
  `bioversions.sources.biogrid` as an example.





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

  <!--


  Citation goes here!
  -->



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



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



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



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

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



  To install in development mode, use the following:

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



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

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

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



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

  ```console
  tox -e py
  ```

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



  The documentation can be built locally using the following:

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

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

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



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





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

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

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



  You only have to do the following steps once.

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



  You have to do the following steps once per machine.

  ```console
  $ uv tool install keyring
  $ keyring set https://upload.pypi.org/legacy/ __token__
  $ keyring set https://test.pypi.org/legacy/ __token__
  ```

  Note that this deprecates previous workflows using `.pypirc`.



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

  ```console
  tox -e finish
  ```

  This script does the following:

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



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

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

  </details>

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


pkgId: 16bd83e9297dd39fd967db60f28495047b2fc265d50987b46bb4496704571148
name: python-bip-utils
arch: src
version: 2.9.3
epoch: 0
release: 1
url: https://github.com/ebellocchia/bip_utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bip-utils-2.9.3-1.src.rpm
checksum_type: sha256
summary:
  Generation of mnemonics, seeds, private/public keys and addresses for different types of cryptocurrencies

description:
  | |
  |---|
  | [![PyPI - Version](https://img.shields.io/pypi/v/bip_utils.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/bip_utils/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bip_utils.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/bip_utils/) [![GitHub License](https://img.shields.io/github/license/ebellocchia/bip_utils?label=License)](https://github.com/ebellocchia/bip_utils?tab=MIT-1-ov-file) |
  | [![Code Coverage](https://github.com/ebellocchia/bip_utils/actions/workflows/code-coverage.yml/badge.svg)](https://github.com/ebellocchia/bip_utils/actions/workflows/code-coverage.yml) [![Code Analysis](https://github.com/ebellocchia/bip_utils/actions/workflows/code-analysis.yml/badge.svg)](https://github.com/ebellocchia/bip_utils/actions/workflows/code-analysis.yml) [![Build & Test](https://github.com/ebellocchia/bip_utils/actions/workflows/test.yml/badge.svg)](https://github.com/ebellocchia/bip_utils/actions/workflows/test.yml) [![Test Requirements](https://github.com/ebellocchia/bip_utils/actions/workflows/test_min_reqs.yml/badge.svg)](https://github.com/ebellocchia/bip_utils/actions/workflows/test_min_reqs.yml) |
  | [![Codecov](https://img.shields.io/codecov/c/github/ebellocchia/bip_utils?label=Code%20Coverage)](https://codecov.io/gh/ebellocchia/bip_utils) [![Codacy grade](https://img.shields.io/codacy/grade/9a0c9c6a3d6444fab91f58fe8ec9e35c?label=Codacy%20Grade)](https://app.codacy.com/gh/ebellocchia/bip_utils/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade) [![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/ebellocchia/bip_utils?label=CodeFactor%20Grade)](https://www.codefactor.io/repository/github/ebellocchia/bip_utils) |
  | |



  This package allows generating mnemonics, seeds, private/public keys and addresses for different types of cryptocurrencies. In particular:
  - Mnemonic and seed generation as defined by [BIP-0039](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki)
  - Private key encryption/decryption as defined by [BIP-0038](https://github.com/bitcoin/bips/blob/master/bip-0038.mediawiki)
  - Keys derivation as defined by:
    - [BIP-0032](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)
    - [SLIP-0010](https://github.com/satoshilabs/slips/blob/master/slip-0010.md)
    - [BIP32-Ed25519 (Khovratovich/Law)](https://github.com/LedgerHQ/orakolo/blob/master/papers/Ed25519_BIP%20Final.pdf)
  - Derivation of a hierarchy of keys as defined by:
    - [BIP-0044](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki)
    - [BIP-0049](https://github.com/bitcoin/bips/blob/master/bip-0049.mediawiki) (Bitcoin Segwit)
    - [BIP-0084](https://github.com/bitcoin/bips/blob/master/bip-0084.mediawiki) (Bitcoin Native Segwit)
    - [BIP-0086](https://github.com/bitcoin/bips/blob/master/bip-0086.mediawiki) (Bitcoin Taproot)
    - [CIP-1852](https://cips.cardano.org/cips/cip1852)
  - Mnemonic and seed generation for [Substrate](https://wiki.polkadot.network/docs/learn-accounts#seed-generation) (Polkadot/Kusama ecosystem)
  - Keys derivation for [Substrate](https://wiki.polkadot.network/docs/learn-accounts#derivation-paths) (Polkadot/Kusama ecosystem, same of Polkadot-JS)
  - Keys and addresses generation for Cardano (Byron-Legacy, Byron-Icarus and Shelley, same of Ledger and AdaLite/Yoroi wallets)
  - Mnemonic and seed generation for Monero
  - Keys and addresses/subaddresses generation for Monero (same of official Monero wallet)
  - Mnemonic and seed generation for Algorand (Algorand 25-word mnemonic)
  - Mnemonic and seed generation like Electrum wallet (v1 and v2)
  - Keys derivation like Electrum wallet (v1 and v2)
  - Generation of keys from a passphrase chosen by the user ("brainwallet")

  Other implemented functionalities:
  - Parse BIP-0032 derivation paths
  - Parse Substrate derivation paths
  - Extended key serialization as defined by [SLIP-0032](https://github.com/satoshilabs/slips/blob/master/slip-0032.md)
  - Encode/Decode addresses for all the supported coins
  - Encode/Decode [WIF](https://en.bitcoin.it/wiki/Wallet_import_format)
  - Encode/Decode [base58](https://en.bitcoin.it/wiki/Base58Check_encoding#Background) and [base58 monero](https://monerodocs.org/cryptography/base58)
  - Encode/Decode [ss58](https://github.com/paritytech/substrate/wiki/External-Address-Format-(SS58))
  - Encode/Decode [bech32](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki) and [bech32m](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki)
  - Encode/Decode [Bitcoin Cash bech32](https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md)
  - Get token account addresses for SPL tokens (i.e. Solana tokens)

  Package dependencies:
  - [cbor2](https://pypi.org/project/cbor2/) for CBOR encoding/decoding
  - [crcmod](https://pypi.org/project/crcmod/) for CRC computation
  - [pycryptodome](https://pypi.org/project/pycryptodome/) for cryptographic functions
  - [coincurve](https://pypi.org/project/coincurve/) for secp256k1 curve
  - [ecdsa](https://pypi.org/project/ecdsa/) for nist256p1 and secp256k1 curves
  - [ed25519-blake2b](https://pypi.org/project/ed25519-blake2b/) for ed25519-blake2b curve
  - [pynacl](https://pypi.org/project/PyNaCl/) for ed25519 curve
  - [py-sr25519-bindings](https://pypi.org/project/py-sr25519-bindings/) for sr25519 curve

  Please note that, for the py-sr25519-bindings library, Rust is required to be installed.



  Supported BIP coins:
  - Akash Network
  - Algorand
  - Aptos
  - Arbitrum
  - Avalanche (all the 3 chains)
  - Axelar
  - Band Protocol
  - Binance Chain
  - Binance Smart Chain
  - Bitcoin (and related test net)
  - Bitcoin Cash (and related test net)
  - Bitcoin Cash Simple Ledger Protocol (and related test net)
  - BitcoinSV (and related test net)
  - Cardano (Byron-Legacy, Byron-Icarus and Shelley)
  - Celo
  - Certik
  - Cosmos
  - Dash (and related test net)
  - Dogecoin (and related test net)
  - eCash (and related test net)
  - Elrond (MultiversX)
  - EOS
  - Ergo (and related test net)
  - Ethereum
  - Ethereum Classic
  - Fantom Opera
  - Filecoin
  - Fetch.ai
  - Harmony One (Ethereum and Cosmos addresses)
  - Huobi Heco Chain
  - IRIS Network
  - Kava
  - Kusama (based on BIP44 and ed25519 SLIP-0010, like TrustWallet, it won't generate the same addresses of Polkadot-JS)
  - Litecoin (and related test net)
  - Metis
  - Monero (based on BIP44 and secp256k1 or ed25519 SLIP-0010, it won't generate the same addresses of the official wallets, but it supports subaddresses generation)
  - Nano
  - Near Protocol
  - NEO
  - OKEx Chain (Ethereum and Cosmos addresses)
  - Ontology
  - Optimism
  - Osmosis
  - Pi Network
  - Polkadot (based on BIP44 and ed25519 SLIP-0010, like TrustWallet, it won't generate the same addresses of Polkadot-JS)
  - Polygon
  - Ripple
  - Secret Network
  - Solana
  - Stafi (Cosmos)
  - Stellar
  - Sui (only ed25519)
  - Terra
  - Tezos
  - Theta Network
  - Tron
  - VeChain
  - Verge
  - Zcash (and related test net)
  - Zilliqa

  Supported Substrate coins:
  - Acala
  - Bifrost
  - Chainx
  - Edgeware
  - Karura
  - Kusama
  - Moonbeam
  - Moonriver
  - Phala Network
  - Plasm Network
  - Sora
  - Stafi
  - Polkadot
  - Generic Substrate coin

  For what regards Monero, it's also possible to generate the same addresses of the official wallets without using BIP44 derivation.

  Clearly, for those coins that support Smart Contracts (e.g. Ethereum, Tron, ...), the generated keys and addresses are valid for all the related tokens.



  For the secp256k1 curve, it's possible to use either the *coincurve* or the *ecdsa* library. *coincurve* is much faster since it's a Python wrapper to the secp256k1 C library, while *ecdsa* is a pure Python implementation.\
  By default *coincurve* will be used, but it's possible to disable it when installing.

  To install the package:
  - Default installation (*coincurve* will be used for secp256k1)
      - Using *pip*, from this directory (local):

              pip install .

      - Using *pip*, from PyPI:

              pip install bip_utils

  - Alternative installation (*ecdsa* will be used for secp256k1)
      - Using *setuptools*:

              python setup.py install --coincurve=0

      - Using *pip*, from this directory (local):

              pip install . --install-option="--coincurve=0"

      - Using *pip*, from PyPI:

              pip install bip_utils --install-option="--coincurve=0"

  **NOTES:**
  - if you are using an Apple M1, please make sure to update *coincurve* to version 17.0.0
  - in case of problems when building the *ed25519_blake2b* library, you can try one of the prebuilt wheels [here](https://github.com/ebellocchia/bip_utils/tree/master/libs_wheels)



  Install develop dependencies:

      pip install -r requirements-dev.txt

  To run tests:

      python -m unittest discover

  To run tests with coverage:

      coverage run -m unittest discover
      coverage report

  To run code analysis, just execute the `analyze_code` script.



  - [BIP-0039](https://github.com/ebellocchia/bip_utils/tree/master/readme/bip39.md)
  - [Algorand mnemonic](https://github.com/ebellocchia/bip_utils/tree/master/readme/algorand_mnemonic.md)
  - [Electrum mnemonic](https://github.com/ebellocchia/bip_utils/tree/master/readme/electrum_mnemonic.md)
  - [Monero mnemonic](https://github.com/ebellocchia/bip_utils/tree/master/readme/monero_mnemonic.md)
  - [BIP-0038](https://github.com/ebellocchia/bip_utils/tree/master/readme/bip38.md)
  - [BIP-0032](https://github.com/ebellocchia/bip_utils/tree/master/readme/bip32.md)
  - [BIP-0044](https://github.com/ebellocchia/bip_utils/tree/master/readme/bip44.md)
  - [Brainwallet](https://github.com/ebellocchia/bip_utils/tree/master/readme/brainwallet.md)
  - [Cardano](https://github.com/ebellocchia/bip_utils/tree/master/readme/cardano.md)
  - [Electrum](https://github.com/ebellocchia/bip_utils/tree/master/readme/electrum.md)
  - [Monero](https://github.com/ebellocchia/bip_utils/tree/master/readme/monero.md)
  - [Substrate](https://github.com/ebellocchia/bip_utils/tree/master/readme/substrate.md)
  - [Utility libraries](https://github.com/ebellocchia/bip_utils/tree/master/readme/utility_libs.md)



  The library documentation is available at [bip-utils.readthedocs.io](https://bip-utils.readthedocs.io).



  For some complete code examples (from mnemonic to keys generation), refer to the [examples](https://github.com/ebellocchia/bip_utils/tree/master/examples) folder.



  You know, I'm italian and I love drinking coffee (especially while coding 😃). So, if you'd like to buy me one:
  - BTC: `bc1qq4r9cglwzd6f2hzxvdkucmdejvr9h8me5hy0k8`
  - ERC20/BEP20: `0xf84e4898E5E10bf1fBe9ffA3EEC845e82e364b5B`

  Thank you very much for your support.



  This software is available under the MIT license.


pkgId: fa0867068a6bd39f79cc50670a5f2a45c6f7295cdce80593b252783bb598a29d
name: python-bip38
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A Python library for implementation of Bitcoin Improvement Proposal - 0038 / BIP38 protocol.
url: https://github.com/meherett/python-bip38
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bip38-1.3.0-1.src.rpm
checksum_type: sha256
description:
  WIF: L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP
  BIP38 Encrypted WIF: 6PYNKZ1EBitZbP8ctdXG5xkpsFAtgd7c9JQdLCXqbhBRbANSnuUK6PgQdV
  BIP38 Decrypted: {
      "wif": "L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP",
      "private_key": "cbf4b9f70470856bb4f40f80b87edb90865997ffee6df315ab166d713af433a5",
      "wif_type": "wif-compressed",
      "public_key": "02d2ce831dd06e5c1f5b1121ef34c2af4bcb01b126e309234adbc3561b60c9360e",
      "public_key_type": "compressed",
      "seed": null,
      "address": "164MQi977u9GUteHr4EPH27VkkdxmfCvGW",
      "lot": null,
      "sequence": null


pkgId: eb77bffbdee858c09b49381541138668328169db23b94b496f628cf6c9edf835
name: python-bip44
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Simple Python bip44 implementation. Mnemonic + bip32.
url: https://github.com/kigawas/python-bip44
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bip44-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/4e4aa71f4a234dca809d014b0b214220)](https://app.codacy.com/gh/kigawas/python-bip44/dashboard)
  [![CI](https://img.shields.io/github/actions/workflow/status/kigawas/python-bip44/ci.yml)](https://github.com/kigawas/python-bip44/actions)
  [![Codecov](https://img.shields.io/codecov/c/github/kigawas/python-bip44.svg)](https://codecov.io/gh/kigawas/python-bip44)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bip44.svg)](https://pypi.org/project/bip44/)
  [![PyPI](https://img.shields.io/pypi/v/bip44.svg)](https://pypi.org/project/bip44/)
  [![License](https://img.shields.io/github/license/kigawas/python-bip44.svg)](https://github.com/kigawas/python-bip44)

  Simple Python [bip44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki) implementation. [Mnemonic](https://github.com/trezor/python-mnemonic) + [bip32](https://github.com/darosior/python-bip32).



  `pip install bip44`



  ```python
  >>> from coincurve import PrivateKey
  >>> from bip44 import Wallet
  >>> from bip44.utils import get_eth_addr
  >>> mnemonic = "purity tunnel grid error scout long fruit false embody caught skin gate"
  >>> w = Wallet(mnemonic)
  >>> sk, pk = w.derive_account("eth", account=0)
  >>> sk = PrivateKey(sk)
  >>> sk.public_key.format() == pk
  True
  >>> get_eth_addr(pk)
  '0x7aD23D6eD9a1D98E240988BED0d78e8C81Ec296C'
  ```





  - Support Python 3.10, 3.11, 3.12
  - Bump dependencies
  - Drop Python 3.6, 3.7



  - First beta release
  - Bump dependencies



  - Alpha releases


pkgId: 4660ff49f80afae2a833f5666f2165ea47e98bafe8be672fcc4bf788f0cb86f3
name: python-bip44
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Simple Python bip44 implementation. Mnemonic + bip32.
url: https://github.com/kigawas/python-bip44
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bip44-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/4e4aa71f4a234dca809d014b0b214220)](https://app.codacy.com/gh/kigawas/python-bip44/dashboard)
  [![CI](https://img.shields.io/github/actions/workflow/status/kigawas/python-bip44/ci.yml)](https://github.com/kigawas/python-bip44/actions)
  [![Codecov](https://img.shields.io/codecov/c/github/kigawas/python-bip44.svg)](https://codecov.io/gh/kigawas/python-bip44)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bip44.svg)](https://pypi.org/project/bip44/)
  [![PyPI](https://img.shields.io/pypi/v/bip44.svg)](https://pypi.org/project/bip44/)
  [![License](https://img.shields.io/github/license/kigawas/python-bip44.svg)](https://github.com/kigawas/python-bip44)

  Simple Python [bip44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki) implementation. [Mnemonic](https://github.com/trezor/python-mnemonic) + [bip32](https://github.com/darosior/python-bip32).



  `pip install bip44`



  ```python
  >>> from coincurve import PrivateKey
  >>> from bip44 import Wallet
  >>> from bip44.utils import get_eth_addr
  >>> mnemonic = "purity tunnel grid error scout long fruit false embody caught skin gate"
  >>> w = Wallet(mnemonic)
  >>> sk, pk = w.derive_account("eth", account=0)
  >>> sk = PrivateKey(sk)
  >>> sk.public_key.format() == pk
  True
  >>> get_eth_addr(pk)
  '0x7aD23D6eD9a1D98E240988BED0d78e8C81Ec296C'
  ```





  - Support Python 3.10, 3.11, 3.12, 3.13
  - Bump dependencies
  - Drop Python 3.6, 3.7



  - First beta release
  - Bump dependencies



  - Alpha releases


pkgId: a54f7bf5c8dee4b4d9f4c5112b73f48d367d5c71d6ebebf7dab19c114c437181
name: python-bipartitepandas
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: Python tools for bipartite labor data
url: https://github.com/tlamadon/bipartitepandas/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bipartitepandas-1.1.10-1.src.rpm
checksum_type: sha256
description:
  `BipartitePandas` is a Python package for handling bipartite labor data.
  If you want to give it a try, you can start the example notebook here: |binder|. This starts a fully interactive notebook with a simple example that generates data and demonstrates some useful functions.
  BipartitePandas is used in `PyTwoWay <https://github.com/tlamadon/pytwoway/>`_.
  The package provides a Python interface. Installation is handled by `pip` or `Conda`. The source of the package is available on GitHub at `BipartitePandas <https://github.com/tlamadon/bipartitepandas>`_. The online documentation is hosted `here <https://tlamadon.github.io/bipartitepandas/>`_.


pkgId: 8af719bba2f3a23f40cc830c4a5222db157938169bcd7a6bbbf8e2ad72b7e4ce
name: python-biplist
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: biplist is a library for reading/writing binary plists.
url: https://bitbucket.org/wooster/biplist
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biplist-1.0.3-1.src.rpm
checksum_type: sha256
description:
  `biplist` is a binary plist parser/generator for Python.

  Binary Property List (plist) files provide a faster and smaller serialization
  format for property lists on OS X. This is a library for generating binary
  plists which can be read by OS X, iOS, or other clients.

  This module requires Python 2.6 or higher or Python 3.4 or higher.


pkgId: e1567aa3d39f6564ad9cd08562b77b060e3fc47ea64e24aadde1027a5e30134e
name: python-birdepy
arch: src
version: 0.0.27
epoch: 0
release: 1
summary: Parameter estimation for birth-and-death processes
url: https://birdepy.github.io
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdepy-0.0.27-1.src.rpm
checksum_type: sha256
description:
  BirDePy is a Python package for working with continuous time birth-and-death processes. It includes functions which can be used to approximate transition probabilities (``birdepy.probability()``), estimate parameter values from data (``birdepy.estimate()``), simulate sample paths (``birdepy.simulate.discrete()`` and ``birdepy.simulate.continuous()``) and generate forecasts (``birdepy.forecast()``). The main focus of the package is the estimation of parameter values from discretely-observed sample paths, however the much more straightforward case of estimation of parameter values from continuously observed sample paths is also included.

  Please visit our website: https://birdepy.github.io/

  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)


pkgId: 20634c9d5885ff7382aef7e615997646c7c057211d9919ae8b86f423165e3d80
name: python-birdepy
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Parameter estimation for birth-and-death processes
url: https://birdepy.github.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdepy-1.0.0-1.src.rpm
checksum_type: sha256
description:
  BirDePy is a Python package for working with continuous time birth-and-death processes. It includes functions which can be used to approximate transition probabilities (``birdepy.probability()``), estimate parameter values from data (``birdepy.estimate()``), simulate sample paths (``birdepy.simulate.discrete()`` and ``birdepy.simulate.continuous()``) and generate forecasts (``birdepy.forecast()``). The main focus of the package is the estimation of parameter values from discretely-observed sample paths, however the much more straightforward case of estimation of parameter values from continuously observed sample paths is also included.

  Please visit our website: https://birdepy.github.io/ and cite our paper:

  Hautphenne S, Patch B (2024). "Birth-and-Death Processes in Python: The BirDePy Package." _Journal of Statistical Software_, (111)5 1-54. [doi: 10.18637/jss.v111.i05](https://doi.org/10.18637/jss.v111.i05).

  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)


pkgId: cf5d7d353d09939260892dae551505db3ab04ab4278a803a71c040e04e91aa96
name: python-birder
arch: src
version: 0.0.5a63
epoch: 0
release: 1
summary: A computer vision framework for wildlife image analysis, focusing on avian species.
url: https://gitlab.com/birder/birder
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birder-0.0.5a63-1.src.rpm
checksum_type: sha256
description:
  Birder is an open-source computer vision framework for wildlife image analysis, focusing on avian species.

  * [Introduction](#introduction)
  * [Setup](#setup)
  * [Getting Started](#getting-started)
  * [Pre-trained Models](#pre-trained-models)
  * [Detection](#detection)
  * [Licenses](#licenses)
  * [Acknowledgments](#acknowledgments)



  Birder is an open-source computer vision framework designed for wildlife imagery, specifically focused on bird species classification and detection. This project leverages deep neural networks to provide robust models that can handle real-world data challenges.

  For comprehensive documentation, tutorials, and more visit the main documentation at [docs/README.md](docs/README.md).

  The project features:

  * A diverse collection of classification and detection models
  * Support for self-supervised pre-training
  * Knowledge distillation training (teacher-student)
  * Custom utilities and data augmentation techniques
  * Comprehensive training scripts
  * Advanced error analysis tools
  * Extensive documentation and tutorials (hopefully...)

  Unlike projects that aim to reproduce ImageNet training results from common papers, Birder is tailored specifically for practical applications in ornithology, conservation, and wildlife photography.

  As Ross Wightman eloquently stated in the [timm README](https://github.com/huggingface/pytorch-image-models#introduction):

  > The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arXiv papers, etc. in the README, documentation, and code docstrings. Please let me know if I missed anything.

  The same principle applies to Birder. We stand on the shoulders of giants in the fields of computer vision, machine learning, and ornithology. We've made every effort to acknowledge and credit the work that has influenced and contributed to this project. If you believe we've missed any attributions, please let us know by opening an issue.



  1. Ensure PyTorch 2.5 is installed on your system

  1. Install the latest Birder version:

  ```sh
  pip install birder
  ```

  For detailed installation options, including source installation, refer to our [Setup Guide](docs/getting_started.md#setup).



  Once Birder is installed, you can start exploring its capabilities.

  Birder provides pre-trained models that you can download using the `fetch-model` tool.
  To download a model, use the following command:

  ```sh
  python -m birder.tools fetch-model mobilenet_v3_large_1
  ```

  Create a data directory and download an example image:

  ```sh
  mkdir data
  wget https://f000.backblazeb2.com/file/birder/data/img_001.jpeg -O data/img_001.jpeg
  ```

  To classify bird images, use the `birder-predict` script as follows:

  ```sh
  birder-predict -n mobilenet_v3_large -p 1 --show data/bird.jpeg
  ```

  For more options and detailed usage of the prediction tool, run:

  ```sh
  birder-predict --help
  ```

  For more detailed usage instructions and examples, please refer to our [documentation](docs/README.md).



  Birder provides a comprehensive suite of pre-trained models for bird species classification.

  To explore the full range of available pre-trained models, use the `list-models` tool:

  ```sh
  python -m birder.tools list-models --pretrained
  ```

  This command displays a catalog of models ready for download.



  The naming convention for Birder models encapsulates key information about their architecture and training approach.

  Architecture: The first part of the model name indicates the core neural network structure (e.g., MobileNet, ResNet).

  Training indicators:

  * intermediate: Signifies models that underwent a two-stage training process, beginning with a large-scale weakly labeled dataset before fine-tuning on the primary dataset
  * mim: Indicates models that leveraged self-supervised pre-training techniques, primarily Masked Autoencoder (MAE), prior to supervised training

  Other tags:

  * quantized: Model that has been quantized to reduce the computational and memory costs of running inference
  * reparameterized: Model that has been restructured to simplify its architecture for optimized inference performance

  Net Param: The number following the model name (e.g., 50, 1.0, 0.5), called the `net_param`, represents a specific configuration choice for the network. It represents a specific configuration choice for the network, which can affect aspects such as model size or complexity.

  Epoch Number (optional): The last part of the model name may include an underscore followed by a number (e.g., `_0`, `_200`), which represents the epoch.

  For instance, *resnext_50_intermediate_300* represents a ResNeXt model with a `net_param` of 50 that underwent intermediate training and is from epoch 300.



  Our pre-training process utilizes a diverse collection of image datasets.
  This approach allows our models to learn rich, general-purpose visual representations before fine-tuning on specific bird classification tasks.

  The pre-training dataset comprises:

  * iNaturalist 2021 (~3.3M)
  * WebVision-2.0 (~1.5M random subset)
  * imagenet-w21-webp-wds (~1M random subset)
  * SA-1B (~220K random subset of 20 chunks)
  * COCO (~120K)
  * NABirds (~48K)
  * Birdsnap v1.1 (~44K)
  * CUB-200 2011 (~18K)
  * The Birder dataset (~5M)

  Total: ~11M images

  This carefully curated mix of datasets balances general visual knowledge with domain-specific bird imagery, enhancing the model's overall performance.

  For detailed information about these datasets, including descriptions, citations, and licensing details, please refer to [docs/public_datasets.md](docs/public_datasets.md).



  Detection features are currently under development and will be available in future releases.

  For annotation, run the following command:

  ```sh
  labelme --labels ../birder/data/detection_data/classes.txt --nodata --output ../birder/data/detection_data/training_annotations --flags unknown ../birder/data/detection_data/training
  ```



  Birder is currently a personal project in active development. As the sole developer, I am focused on building and refining the core functionalities of the framework. At this time, I am not actively seeking external contributors.

  However, I greatly appreciate the interest and support from the community. If you have suggestions, find bugs, or want to provide feedback, please feel free to:

  * Open an issue in the project's issue tracker
  * Use the project and share your experiences
  * Star the repository if you find it useful

  While I may not be able to incorporate external contributions at this stage, your input is valuable and helps shape the direction of Birder. I'll update this section if the contribution policy changes in the future.

  Thank you for your understanding and interest in Birder!





  The code in this project is licensed under Apache 2.0. See [LICENSE](LICENSE) for details.
  Some code is adapted from other projects.
  There are notices with links to the references at the top of the file or at the specific class/function.
  It is your responsibility to ensure compliance with licenses here and conditions of any dependent licenses.

  If you think we've missed a reference or a license, please create an issue.



  Some of the pretrained weights available here are pretrained on ImageNet. ImageNet was released for non-commercial research purposes only (<https://image-net.org/download>). It's not clear what the implications of that are for the use of pretrained weights from that dataset. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.



  If you intend to use Birder, its pretrained weights, or any associated datasets in a commercial product, we strongly recommend seeking legal advice to ensure compliance with all relevant licenses and terms of use.

  It's the user's responsibility to ensure that their use of this project, including any pretrained weights or datasets, complies with all applicable licenses and legal requirements.



  Birder owes much to the work of others in computer vision, machine learning, and ornithology.

  Special thanks to:

  * **Ross Wightman**: His work on [PyTorch Image Models (timm)](https://github.com/huggingface/pytorch-image-models) greatly inspired the design and approach of Birder.

  * **Image Contributors**:
    * Yaron Schmid - from [YS Wildlife](https://www.yswildlifephotography.com/who-we-are)

    for their generous donations of bird photographs.

  This project also benefits from numerous open-source libraries and ornithological resources.

  If any attribution is missing, please open an issue to let us know.


pkgId: bf7ffaaae07644d84b0df9906df8db7779ec2a5a3a0eca485453b7fffa7650d6
name: python-birder
arch: src
version: 0.0.5a72
epoch: 0
release: 1
summary: A computer vision framework for wildlife image analysis, focusing on avian species.
url: https://gitlab.com/birder/birder
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birder-0.0.5a72-1.src.rpm
checksum_type: sha256
description:
  Birder is an open-source computer vision framework for wildlife image analysis, focusing on avian species.

  * [Introduction](#introduction)
  * [Setup](#setup)
  * [Getting Started](#getting-started)
  * [Pre-trained Models](#pre-trained-models)
  * [Detection](#detection)
  * [Licenses](#licenses)
  * [Acknowledgments](#acknowledgments)



  Birder is an open-source computer vision framework designed for wildlife imagery, specifically focused on bird species classification and detection. This project leverages deep neural networks to provide robust models that can handle real-world data challenges.

  For comprehensive documentation, tutorials, and more visit the main documentation at [docs/README.md](docs/README.md).

  The project features:

  * A diverse collection of classification and detection models
  * Support for self-supervised pre-training
  * Knowledge distillation training (teacher-student)
  * Custom utilities and data augmentation techniques
  * Comprehensive training scripts
  * Advanced error analysis tools
  * Extensive documentation and tutorials (hopefully...)

  Unlike projects that aim to reproduce ImageNet training results from common papers, Birder is tailored specifically for practical applications in ornithology, conservation, and wildlife photography.

  As Ross Wightman eloquently stated in the [timm README](https://github.com/huggingface/pytorch-image-models#introduction):

  > The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arXiv papers, etc. in the README, documentation, and code docstrings. Please let me know if I missed anything.

  The same principle applies to Birder. We stand on the shoulders of giants in the fields of computer vision, machine learning, and ornithology. We've made every effort to acknowledge and credit the work that has influenced and contributed to this project. If you believe we've missed any attributions, please let us know by opening an issue.



  1. Ensure PyTorch 2.5 is installed on your system

  1. Install the latest Birder version:

  ```sh
  pip install birder
  ```

  For detailed installation options, including source installation, refer to our [Setup Guide](docs/getting_started.md#setup).



  Check out the Birder Colab notebook for an interactive tutorial.

  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/birder-project/birder/blob/main/notebooks/getting_started.ipynb)

  If you prefer a local setup, follow the installation instructions below.

  Once Birder is installed, you can start exploring its capabilities.

  Birder provides pre-trained models that you can download using the `fetch-model` tool.
  To download a model, use the following command:

  ```sh
  python -m birder.tools fetch-model mobilenet_v3_large_1_il-common
  ```

  Create a data directory and download an example image:

  ```sh
  mkdir data
  wget https://f000.backblazeb2.com/file/birder/data/img_001.jpeg -O data/img_001.jpeg
  ```

  To classify bird images, use the `birder-predict` script as follows:

  ```sh
  birder-predict -n mobilenet_v3_large -t il-common -p 1 --show data/img_001.jpeg
  ```

  For more options and detailed usage of the prediction tool, run:

  ```sh
  birder-predict --help
  ```

  For more detailed usage instructions and examples, please refer to our [documentation](docs/README.md).



  Birder provides a comprehensive suite of pre-trained models for bird species classification.

  To explore the full range of available pre-trained models, use the `list-models` tool:

  ```sh
  python -m birder.tools list-models --pretrained
  ```

  This command displays a catalog of models ready for download.



  The naming convention for Birder models encapsulates key information about their architecture and training approach.

  Architecture: The first part of the model name indicates the core neural network structure (e.g., MobileNet, ResNet).

  Training indicators:

  * intermediate: Signifies models that underwent a two-stage training process, beginning with a large-scale weakly labeled dataset before fine-tuning on the primary dataset
  * mim: Indicates models that leveraged self-supervised pre-training techniques, primarily Masked Autoencoder (MAE), prior to supervised training

  Other tags:

  * quantized: Model that has been quantized to reduce the computational and memory costs of running inference
  * reparameterized: Model that has been restructured to simplify its architecture for optimized inference performance

  Net Param: The number following the model name (e.g., 50, 1.0, 0.5), called the `net_param`, represents a specific configuration choice for the network. It represents a specific configuration choice for the network, which can affect aspects such as model size or complexity.

  Epoch Number (optional): The last part of the model name may include an underscore followed by a number (e.g., `_0`, `_200`), which represents the epoch.

  For instance, *resnext_50_intermediate_300* represents a ResNeXt model with a `net_param` of 50 that underwent intermediate training and is from epoch 300.



  Our pre-training process utilizes a diverse collection of image datasets.
  This approach allows our models to learn rich, general-purpose visual representations before fine-tuning on specific bird classification tasks.

  The pre-training dataset comprises:

  * iNaturalist 2021 (~3.3M)
  * WebVision-2.0 (~1.5M random subset)
  * imagenet-w21-webp-wds (~1M random subset)
  * SA-1B (~220K random subset of 20 chunks)
  * COCO (~120K)
  * NABirds (~48K)
  * Birdsnap v1.1 (~44K)
  * CUB-200 2011 (~18K)
  * The Birder dataset (~5M)

  Total: ~11M images

  This carefully curated mix of datasets balances general visual knowledge with domain-specific bird imagery, enhancing the model's overall performance.

  For detailed information about these datasets, including descriptions, citations, and licensing details, please refer to [docs/public_datasets.md](docs/public_datasets.md).



  Detection features are currently under development and will be available in future releases.

  For annotation, run the following command:

  ```sh
  labelme --labels ../birder/data/detection_data/classes.txt --nodata --output ../birder/data/detection_data/training_annotations --flags unknown ../birder/data/detection_data/training
  ```



  Birder is currently a personal project in active development. As the sole developer, I am focused on building and refining the core functionalities of the framework. At this time, I am not actively seeking external contributors.

  However, I greatly appreciate the interest and support from the community. If you have suggestions, find bugs, or want to provide feedback, please feel free to:

  * Open an issue in the project's issue tracker
  * Use the project and share your experiences
  * Star the repository if you find it useful

  While I may not be able to incorporate external contributions at this stage, your input is valuable and helps shape the direction of Birder. I'll update this section if the contribution policy changes in the future.

  Thank you for your understanding and interest in Birder!





  The code in this project is licensed under Apache 2.0. See [LICENSE](LICENSE) for details.
  Some code is adapted from other projects.
  There are notices with links to the references at the top of the file or at the specific class/function.
  It is your responsibility to ensure compliance with licenses here and conditions of any dependent licenses.

  If you think we've missed a reference or a license, please create an issue.



  Some of the pretrained weights available here are pretrained on ImageNet. ImageNet was released for non-commercial research purposes only (<https://image-net.org/download>). It's not clear what the implications of that are for the use of pretrained weights from that dataset. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.



  If you intend to use Birder, its pretrained weights, or any associated datasets in a commercial product, we strongly recommend seeking legal advice to ensure compliance with all relevant licenses and terms of use.

  It's the user's responsibility to ensure that their use of this project, including any pretrained weights or datasets, complies with all applicable licenses and legal requirements.



  Birder owes much to the work of others in computer vision, machine learning, and ornithology.

  Special thanks to:

  * **Ross Wightman**: His work on [PyTorch Image Models (timm)](https://github.com/huggingface/pytorch-image-models) greatly inspired the design and approach of Birder.

  * **Image Contributors**:
    * Yaron Schmid - from [YS Wildlife](https://www.yswildlifephotography.com/who-we-are)

    for their generous donations of bird photographs.

  This project also benefits from numerous open-source libraries and ornithological resources.

  If any attribution is missing, please open an issue to let us know.


pkgId: 91f42f087e6e90b45277956675d5d0bfb5994082fcb9678a3d357f9a32a2c817
name: python-birder
arch: src
version: 0.0.5a75
epoch: 0
release: 1
summary: A computer vision framework for wildlife image analysis, focusing on avian species.
url: https://gitlab.com/birder/birder
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birder-0.0.5a75-1.src.rpm
checksum_type: sha256
description:
  Birder is an open-source computer vision framework for wildlife image analysis, focusing on avian species.

  * [Introduction](#introduction)
  * [Setup](#setup)
  * [Getting Started](#getting-started)
  * [Pre-trained Models](#pre-trained-models)
  * [Detection](#detection)
  * [Licenses](#licenses)
  * [Acknowledgments](#acknowledgments)



  Birder is an open-source computer vision framework designed for wildlife imagery, specifically focused on bird species classification and detection. This project leverages deep neural networks to provide robust models that can handle real-world data challenges.

  For comprehensive documentation, tutorials, and more visit the main documentation at [docs/README.md](docs/README.md).

  The project features:

  * A diverse collection of classification and detection models
  * Support for self-supervised pre-training
  * Knowledge distillation training (teacher-student)
  * Custom utilities and data augmentation techniques
  * Comprehensive training scripts
  * Advanced error analysis tools
  * Extensive documentation and tutorials (hopefully...)

  Unlike projects that aim to reproduce ImageNet training results from common papers, Birder is tailored specifically for practical applications in ornithology, conservation, and wildlife photography.

  As Ross Wightman eloquently stated in the [timm README](https://github.com/huggingface/pytorch-image-models#introduction):

  > The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arXiv papers, etc. in the README, documentation, and code docstrings. Please let me know if I missed anything.

  The same principle applies to Birder. We stand on the shoulders of giants in the fields of computer vision, machine learning, and ornithology. We've made every effort to acknowledge and credit the work that has influenced and contributed to this project. If you believe we've missed any attributions, please let us know by opening an issue.



  1. Ensure PyTorch 2.5 is installed on your system

  1. Install the latest Birder version:

  ```sh
  pip install birder
  ```

  For detailed installation options, including source installation, refer to our [Setup Guide](docs/getting_started.md#setup).



  ![Example](docs/img/example.jpeg)

  Check out the Birder Colab notebook for an interactive tutorial.

  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/birder-project/birder/blob/main/notebooks/getting_started.ipynb)

  If you prefer a local setup, follow the installation instructions below.

  Once Birder is installed, you can start exploring its capabilities.

  Birder provides pre-trained models that you can download using the `fetch-model` tool.
  To download a model, use the following command:

  ```sh
  python -m birder.tools fetch-model mvit_v2_t_il-all
  ```

  Create a data directory and download an example image:

  ```sh
  mkdir data
  wget https://f000.backblazeb2.com/file/birder/data/img_001.jpeg -O data/img_001.jpeg
  ```

  To classify bird images, use the `birder-predict` script as follows:

  ```sh
  birder-predict -n mvit_v2_t -t il-all --show data/img_001.jpeg
  ```

  For more options and detailed usage of the prediction tool, run:

  ```sh
  birder-predict --help
  ```

  For more detailed usage instructions and examples, please refer to our [documentation](docs/README.md).



  Birder provides a comprehensive suite of pre-trained models for bird species classification.

  To explore the full range of available pre-trained models, use the `list-models` tool:

  ```sh
  python -m birder.tools list-models --pretrained
  ```

  This command displays a catalog of models ready for download.



  The naming convention for Birder models encapsulates key information about their architecture and training approach.

  Architecture: The first part of the model name indicates the core neural network structure (e.g., MobileNet, ResNet).

  Training indicators:

  * intermediate: Signifies models that underwent a two-stage training process, beginning with a large-scale weakly labeled dataset before fine-tuning on the primary dataset
  * mim: Indicates models that leveraged self-supervised pre-training techniques, primarily Masked Autoencoder (MAE), prior to supervised training

  Other tags:

  * quantized: Model that has been quantized to reduce the computational and memory costs of running inference
  * reparameterized: Model that has been restructured to simplify its architecture for optimized inference performance

  Net Param: The number following the model name (e.g., 50, 1.0, 0.5), called the `net_param`, represents a specific configuration choice for the network. It represents a specific configuration choice for the network, which can affect aspects such as model size or complexity.

  Epoch Number (optional): The last part of the model name may include an underscore followed by a number (e.g., `_0`, `_200`), which represents the epoch.

  For instance, *resnext_50_intermediate_300* represents a ResNeXt model with a `net_param` of 50 that underwent intermediate training and is from epoch 300.



  Our pre-training process utilizes a diverse collection of image datasets.
  This approach allows our models to learn rich, general-purpose visual representations before fine-tuning on specific bird classification tasks.

  The pre-training dataset comprises:

  * iNaturalist 2021 (~3.3M)
  * WebVision-2.0 (~1.5M random subset)
  * imagenet-w21-webp-wds (~1M random subset)
  * SA-1B (~220K random subset of 20 chunks)
  * COCO (~120K)
  * NABirds (~48K)
  * Birdsnap v1.1 (~44K)
  * CUB-200 2011 (~18K)
  * The Birder dataset (~5M)

  Total: ~11M images

  This carefully curated mix of datasets balances general visual knowledge with domain-specific bird imagery, enhancing the model's overall performance.

  For detailed information about these datasets, including descriptions, citations, and licensing details, please refer to [docs/public_datasets.md](docs/public_datasets.md).



  Detection features are currently under development and will be available in future releases.

  For annotation, run the following command:

  ```sh
  labelme --labels ../birder/data/detection_data/classes.txt --nodata --output ../birder/data/detection_data/training_annotations --flags unknown ../birder/data/detection_data/training
  ```



  Birder is currently a personal project in active development. As the sole developer, I am focused on building and refining the core functionalities of the framework. At this time, I am not actively seeking external contributors.

  However, I greatly appreciate the interest and support from the community. If you have suggestions, find bugs, or want to provide feedback, please feel free to:

  * Open an issue in the project's issue tracker
  * Use the project and share your experiences
  * Star the repository if you find it useful

  While I may not be able to incorporate external contributions at this stage, your input is valuable and helps shape the direction of Birder. I'll update this section if the contribution policy changes in the future.

  Thank you for your understanding and interest in Birder!





  The code in this project is licensed under Apache 2.0. See [LICENSE](LICENSE) for details.
  Some code is adapted from other projects.
  There are notices with links to the references at the top of the file or at the specific class/function.
  It is your responsibility to ensure compliance with licenses here and conditions of any dependent licenses.

  If you think we've missed a reference or a license, please create an issue.



  Some of the pretrained weights available here are pretrained on ImageNet. ImageNet was released for non-commercial research purposes only (<https://image-net.org/download>). It's not clear what the implications of that are for the use of pretrained weights from that dataset. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.



  If you intend to use Birder, its pretrained weights, or any associated datasets in a commercial product, we strongly recommend seeking legal advice to ensure compliance with all relevant licenses and terms of use.

  It's the user's responsibility to ensure that their use of this project, including any pretrained weights or datasets, complies with all applicable licenses and legal requirements.



  Birder owes much to the work of others in computer vision, machine learning, and ornithology.

  Special thanks to:

  * **Ross Wightman**: His work on [PyTorch Image Models (timm)](https://github.com/huggingface/pytorch-image-models) greatly inspired the design and approach of Birder.

  * **Image Contributors**:
    * Yaron Schmid - from [YS Wildlife](https://www.yswildlifephotography.com/who-we-are)

    for their generous donations of bird photographs.

  This project also benefits from numerous open-source libraries and ornithological resources.

  If any attribution is missing, please open an issue to let us know.


pkgId: ff1f1255acacc8e0d5dc9301a8a5580356cfe2b7c2026f554fd2cd3ccbe30690
name: python-birdeye-py
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Python wrapper for birdeye.so api
url: https://github.com/nickatnight/birdeye-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdeye-py-0.0.1-1.src.rpm
checksum_type: sha256
description:
  If you would like to support development efforts, tips are greatly appreciated. SOL address: HKmUpKBCcZGVX8RqLRcKyjYuY23hQHwnFSHXzdon4pCH


pkgId: 88045e7fc719f691e8c8a6c183e7a778ba8672f52b49c1e0fc9c4316557e5731
name: python-birdeye-py
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Python wrapper for birdeye.so api
url: https://github.com/nickatnight/birdeye-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdeye-py-0.0.2-1.src.rpm
checksum_type: sha256
description:
  If you would like to support development efforts, tips are greatly appreciated. SOL wallet address: HKmUpKBCcZGVX8RqLRcKyjYuY23hQHwnFSHXzdon4pCH


pkgId: 3e72f4795a59d7a75db3d049e13664eb00547b2616fefff097ef75fab948385d
name: python-birdhousebuilder.recipe.docker
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: A Buildout recipe to generate a Dockerfile for Birdhouse applications.
url: https://github.com/bird-house/birdhousebuilder.recipe.docker
rpm_license: Apache License 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdhousebuilder.recipe.docker-0.5.3-1.src.rpm
checksum_type: sha256
description:
  This recipe supports the following options:
  **app**
     The name of your application. Default: birdhouse
  **maintainer**
     The maintainer of the Dockerfile.
  **description**
     Description of the Dockerfile.
  **vendor**
     The vendor of the application. Default: Birdhouse
  **version**
     The version of the application. Default: 1.0.0
  **hostname**
     The hostname of the docker container. Default: localhost
  **http-port**
     The HTTP port of the app service. Default: 8080
  **https-port**
     The HTTPS port of the app service. Default: 8443
  **output-port**
     The WPS output port of the wps apps service. Default: 8000


pkgId: 34909be57d7732e957c5067d6eaa5a8e50808d4343b22889534b8e4308d7dd82
name: python-birdhousebuilder.recipe.pywps
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A Buildout recipe to install and configure PyWPS Web Processing Service with conda.
url: https://github.com/bird-house/birdhousebuilder.recipe.pywps
rpm_license: Apache License 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdhousebuilder.recipe.pywps-0.10.0-1.src.rpm
checksum_type: sha256
description:
  The PyWPS options which are configured by buildout are explained in the `PyWPS documentation`_.
  The recipe supports the following buildout options:
  **anaconda-home**
     Buildout option pointing to the root folder of the Anaconda installation. Default: ``$HOME/anaconda``.
  Buildout options for ``pywps``:
  **prefix**
    Deployment option to set the prefix of the installation folder. Default: ``/``
  **user**
    Deployment option to set the run user.
  **etc-user**
    Deployment option to set the user of the ``/etc`` directory. Default: ``root``
  **name**
     The name of your WPS project (used for config names and folder path).
  **hostname**
     The hostname of the ``PyWPS`` service (nginx). Default: ``localhost``
  **http-port**
     The http port of the ``PyWPS`` service (nginx). Default: ``8091``
  **https-port**
     The https port of the ``PyWPS`` service (nginx). Default: ``28091``
  **http-output-port**, **output-port**
     The http port of the ``PyWPS`` output file service (nginx). Default: ``8090``
  **https-output-port**
     The https port of the ``PyWPS`` output file service (nginx). Default: ``28090``
  **ssl-verify-client**
   Nginx option to verify SSL client certificates. Possible values: ``off`` (default), ``on``, ``optional``.
   `Nginx ssl_verify_client option`_
  **ssl-client-certificate**
   Nginx option with the name of the bundle of CA certificates for the client. Default: ``esgf-ca-bundle.crt``.
   `Nginx ssl_client_certificate`_
  **ssl-client-certificate-url**
   Optional URL to download a bundle of CA certificates for ``ssl-client-certificate``. Default:
   https://github.com/ESGF/esgf-dist/raw/master/installer/certs/esgf-ca-bundle.crt
  **workers**
     The number of gunicorn workers for handling requests. Default: 1
  **application**
     PyWPS WSGI Application. Default: ``${name}:application``.
  **title**
     Title used for your WPS service.
  **abstract**
     Description of your WPS service.
  **loglevel**
     Logging level for ``PyWPS``. Default: ``WARN``
  **logformat**
     Logging string format for ``PyWPS``. Default: ``s] [s] line=s module=s s``
  **database**
     Database where the logs about requests/responses is to be stored. Allowed values are ``memory`` or ``sqlite``.
     Default: ``sqlite``.
  **parallelprocesses**
     Maximum number of parallel running processes.
     The effective number of parallel running processes is limited by the number of cores
     in the hosting machine. Default: 2
  **maxprocesses**
     Maximum number of processes which are accepted in the queue. Default: 30
  **maxrequestsize**
     Maximal request size accepted in WPS process. Default: 30mb
  **allowedinputpaths**
     List of server paths which are allowed to be accessed by file URL complex input parameters.
  **mode**
     Processing mode to run jobs. Allowed values are ``default`` (multiprocessing) and ``slurm``.
     Default: default


pkgId: 589057be6e308b391bf233dcbb015c92aed3af1dce20b549f67554ba56d6a8c2
name: python-birdnet
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: A Python library for identifying bird species by their sounds.
url: https://github.com/birdnet-team/birdnet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdnet-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/birdnet.svg)](https://pypi.python.org/pypi/birdnet)
  ![PyPI](https://img.shields.io/pypi/pyversions/birdnet.svg)
  [![MIT](https://img.shields.io/github/license/birdnet-team/birdnet.svg)](https://github.com/birdnet-team/birdnet/blob/main/LICENSE.md)

  A Python library for identifying bird species by their sounds.

  The library is geared towards providing a robust workflow for ecological data analysis in bioacoustic projects. While it covers essential functionalities, it doesn’t include all the features found in BirdNET-Analyzer, which is available [here](https://github.com/kahst/BirdNET-Analyzer). Some features might only be available in the BirdNET Analyzer and not in this package.

  Please note that the project is under active development, so you might encounter changes that could affect your current workflow. We recommend checking for updates regularly.

  The package is also available as an R package at: [birdnetR](https://github.com/birdnet-team/birdnetR).



  ```sh

  pip install birdnet --user


  pip install birdnet[and-cuda] --user
  ```





  ```py
  from pathlib import Path

  from birdnet import SpeciesPredictions, predict_species_within_audio_file


  audio_path = Path("example/soundscape.wav")
  predictions = SpeciesPredictions(predict_species_within_audio_file(audio_path))


  prediction, confidence = list(predictions[(0.0, 3.0)].items())[0]
  print(f"predicted '{prediction}' with a confidence of {confidence:.2f}")


  ```

  The resulting `predictions` look like this (excerpt, scores may vary):

  ```py
  from birdnet import SpeciesPredictions, SpeciesPrediction

  predictions = SpeciesPredictions([
    ((0.0, 3.0), SpeciesPrediction([
      ('Poecile atricapillus_Black-capped Chickadee', 0.8140561)
    ])),
    ((3.0, 6.0), SpeciesPrediction([
      ('Poecile atricapillus_Black-capped Chickadee', 0.3082859)
    ])),
    ((6.0, 9.0), SpeciesPrediction([
      ('Baeolophus bicolor_Tufted Titmouse', 0.1864328)
    ])),
    ((9.0, 12.0), SpeciesPrediction([
      ('Haemorhous mexicanus_House Finch', 0.639378)
    ])),
    ((12.0, 15.0), SpeciesPrediction()),
    ((15.0, 18.0), SpeciesPrediction()),
    ((18.0, 21.0), SpeciesPrediction([
      ('Cyanocitta cristata_Blue Jay', 0.4352715),
      ('Clamator coromandus_Chestnut-winged Cuckoo', 0.32258758)
    ])),
    ((21.0, 24.0), SpeciesPrediction([
      ('Cyanocitta cristata_Blue Jay', 0.32908556),
      ('Haemorhous mexicanus_House Finch', 0.18672176)
    ])),
    ...
  ])
  ```

  For a more detailed prediction you can take a look at [example/example.py](./example/example.py).



  ```py
  from birdnet import predict_species_at_location_and_time


  prediction = predict_species_at_location_and_time(42.5, -76.45, week=4)


  first_species, confidence = list(prediction.items())[0]
  print(f"predicted '{first_species}' with a confidence of {confidence:.2f}")


  ```



  ```py
  from pathlib import Path

  from birdnet import predict_species_within_audio_files_mp

  files = (
    Path("example/soundscape.wav"),
    Path("example/soundscape.wav"),
    Path("example/soundscape.wav"),
    Path("example/soundscape.wav"),
  )

  file_predictions = list(predict_species_within_audio_files_mp(files))

  for file, predictions in file_predictions:
    print(file.name, len(predictions), "predictions")





  ```



  The audio models support all formats compatible with the SoundFile library (see [here](https://python-soundfile.readthedocs.io/en/0.11.0/#read-write-functions)). This includes, but is not limited to, WAV, FLAC, OGG, and AIFF. The flexibility of supported formats ensures that the models can handle a wide variety of audio input types, making them adaptable to different use cases and environments.



  This project provides two model formats: Protobuf/Raven and TFLite. Both models are designed to have identical precision up to 2 decimal places, with differences only appearing from the third decimal place onward.

  - **Protobuf Model**: Accessed via `AudioModelV2M4Protobuf()`/`MetaModelV2M4Protobuf()`/`CustomAudioModelV2M4Raven()`, this model can be executed on both GPU and CPU. By default, the Protobuf model is used, and the system will attempt to run it on the GPU if available.
  - **TFLite Model**: Accessed via `AudioModelV2M4TFLite()`/`MetaModelV2M4TFLite()`/`CustomAudioModelV2M4TFLite()`, this model is limited to CPU execution only.

  Ensure your environment is configured to utilize the appropriate model and available hardware optimally.



  - **Source Code**: The source code for this project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
  - **Models**: The models used in this project are licensed under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/).

  Please ensure you review and adhere to the specific license terms provided with each model. Note that educational and research purposes are considered non-commercial use cases.



  Feel free to use birdnet for your acoustic analyses and research. If you do, please cite as:

  ```bibtex
  @article{kahl2021birdnet,
    title={BirdNET: A deep learning solution for avian diversity monitoring},
    author={Kahl, Stefan and Wood, Connor M and Eibl, Maximilian and Klinck, Holger},
    journal={Ecological Informatics},
    volume={61},
    pages={101236},
    year={2021},
    publisher={Elsevier}
  }
  ```



  This project is supported by Jake Holshuh (Cornell class of '69) and The Arthur Vining Davis Foundations. Our work in the K. Lisa Yang Center for Conservation Bioacoustics is made possible by the generosity of K. Lisa Yang to advance innovative conservation technologies to inspire and inform the conservation of wildlife and habitats.

  The German Federal Ministry of Education and Research is funding the development of BirdNET through the project "BirdNET+" (FKZ 01|S22072).
  Additionally, the German Federal Ministry of Environment, Nature Conservation and Nuclear Safety is funding the development of BirdNET through the project "DeepBirdDetect" (FKZ 67KI31040E).



  BirdNET is a joint effort of partners from academia and industry.
  Without these partnerships, this project would not have been possible.
  Thank you!

  ![Our partners](https://tuc.cloud/index.php/s/KSdWfX5CnSRpRgQ/download/box_logos.png)


pkgId: 526147360b9588b5e1f323972c756d2740e2c6ce6d38a7792b98f7e58ff3137c
name: python-birdnetlib
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: A python api for BirdNET-Lite and BirdNET-Analyzer
url: https://pypi.org/project/birdnetlib/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdnetlib-0.18.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/birdnetlib.svg)](https://pypi.org/project/birdnetlib/)
  [![Python 3.x](https://img.shields.io/pypi/pyversions/birdnetlib.svg?logo=python&logoColor=white)](https://pypi.org/project/birdnetlib/)
  [![Test](https://github.com/joeweiss/birdnetlib/actions/workflows/test.yml/badge.svg)](https://github.com/joeweiss/birdnetlib/actions/workflows/test.yml)

  A python api for BirdNET-Analyzer and BirdNET-Lite

  `birdnetlib` provides a common interface for BirdNET-Analyzer and BirdNET-Lite.



  Documentation is at [https://joeweiss.github.io/birdnetlib](https://joeweiss.github.io/birdnetlib/).

  See [Getting Started](https://joeweiss.github.io/birdnetlib/getting-started/) for a quick introduction.



  `birdnetlib` requires Python 3.9+ and prior installation of Tensorflow Lite, librosa and ffmpeg. See [BirdNET-Analyzer](https://github.com/kahst/BirdNET-Analyzer#setup-ubuntu) for more details on installing the Tensorflow-related dependencies.

  ```bash
  pip install birdnetlib
  ```



  To use the latest BirdNET-Analyzer model, use the `Analyzer` class.

  ```python
  from birdnetlib import Recording
  from birdnetlib.analyzer import Analyzer
  from datetime import datetime


  analyzer = Analyzer()

  recording = Recording(
      analyzer,
      "sample.mp3",
      lat=35.4244,
      lon=-120.7463,
      date=datetime(year=2022, month=5, day=10), # use date or week_48
      min_conf=0.25,
  )
  recording.analyze()
  print(recording.detections)
  ```

  `recording.detections` contains a list of detected species, along with time ranges and confidence value.

  ```bash
  [{'common_name': 'House Finch',
    'confidence': 0.5744,
    'end_time': 12.0,
    'scientific_name': 'Haemorhous mexicanus',
    'start_time': 9.0,
    'label': 'Haemorhous mexicanus_House Finch'},
   {'common_name': 'House Finch',
    'confidence': 0.4496,
    'end_time': 15.0,
    'scientific_name': 'Haemorhous mexicanus',
    'start_time': 12.0,
    'label': 'Haemorhous mexicanus_House Finch'}]
  ```

  The `Recording` class takes a file path as an argument. You can also use `RecordingFileObject` to analyze an in-memory object, or `RecordingBuffer` for handling an array buffer.



  `birdnetlib` uses models provided by BirdNET-Lite and BirdNET-Analyzer under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License](https://github.com/kahst/BirdNET-Analyzer/blob/main/LICENSE).

  BirdNET-Lite and BirdNET-Analyzer were developed by the [K. Lisa Yang Center for Conservation Bioacoustics](https://www.birds.cornell.edu/ccb/) at the [Cornell Lab of Ornithology](https://www.birds.cornell.edu/home).

  For more information on BirdNET analyzers, please see the project repositories below:

  [BirdNET-Analyzer](https://github.com/kahst/BirdNET-Analyzer)

  [BirdNET-Lite](https://github.com/kahst/BirdNET-Lite)

  `birdnetlib` is not associated with BirdNET-Lite, BirdNET-Analyzer or the K. Lisa Yang Center for Conservation Bioacoustics.



  `birdnetlib` is maintained by Joe Weiss. Contributions are welcome.



  - Establish a unified API for interacting with Tensorflow-based BirdNET analyzers
  - Enable python-based test cases for BirdNET analyzers
  - Make it easier to use BirdNET in python-based projects
  - Make it easier to migrate to new BirdNET versions/models as they become available


pkgId: 9a15604fda5da8c79e5783ac7c6b62ae64a3a77df19da13b0b1daa0080699262
name: python-birdvoxdetect
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Bioacoustic monitoring of nocturnal bird migration
url: https://github.com/BirdVox/birdvoxdetect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birdvoxdetect-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/badge/python-3.6-blue.svg)]()
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://choosealicense.com/licenses/mit/)

  BirdVoxDetect is a pre-trained deep learning system which detects flight calls from songbirds in audio recordings, and retrieves the corresponding species.
  It relies on per-channel energy normalization (PCEN) and context-adaptive convolutional neural networks (CA-CNN) for improved robustness to background noise.
  It is made available both as a Python library and as a command-line tool for Windows, OS X, and GNU/Linux.




  The simplest way to install BirdVoxDetect is by using the ``pip`` package management system, which will also install the additional required dependencies
  if needed.

      pip install birdvoxdetect

   Note that birdvoxdetect requires:
  * Python (3.6, 3.7, or 3.8)
  * librosa (==0.7.0)
  * tensorflow (>=2.2)
  * scikit-learn (==0.21.2)
  * birdvoxclassify (>=0.3)
  * h5py
  * pandas






  To analyze one file:

      birdvoxdetect path/to/file.wav

  To analyze multiple files:

      birdvoxdetect path/to/file1.wav path/to/file2.wav

  To analyze one folder:

      birdvoxdetect path/to/folder

  On Windows:

      birdvoxdetect path\to\folder

  Optional arguments:

      --clip-duration CLIP_DURATION, -d CLIP_DURATION
                            Duration of the exported clips, expressed in seconds
                            (fps). The default value is 1.0, that is, one second.
                            We recommend values of 0.5 or above.
      --export-clips, -c    Export detected events as audio clips in WAV format.
      --export-confidence, -C
                            Export the time series of model confidence values of
                            events in HDF5 format.
      --export-faults, -f   Export list of sensor faults in CSV format.
      --export-logger, -l   Export output of Python logger in TXT format.
      --output-dir OUTPUT_DIR, -o OUTPUT_DIR
                            Directory to save the output file(s); The default
                            value is the same directory as the input file(s).
      --predict-proba, -p   Export output probabilities in JSON format.
      --quiet, -q           Print less messages on screen.
      --suffix SUFFIX, -s SUFFIX
                            String to append to the output filenames.The default
                            value is the empty string.
      --threshold THRESHOLD, -t THRESHOLD
                            Detection threshold, between 10 and 90. The default
                            value is 50. Greater values lead to higher precision
                            at the expense of a lower recall.
      --verbose, -v         Print timestamps of detected events.
      --version, -V         Print version number.




  Call syntax:

      import birdvoxdetect as bvd
      df = bvd.process_file('path/to/file.wav')

  `df` is a Pandas DataFrame with three columns: time, detection confidence, and species.

  Below is a typical output from the test suite (file path `tests/data/audio/fd79e55d-d3a3-4083-aba1-4f00b545c3d6.wav`):

      Time (hh:mm:ss),Detection confidence (%),Order,Order confidence (%),Family,Family confidence (%),Species (English name),Species (scientific name),Species (4-letter code),Species confidence (%)
      0,00:00:08.78,70.15%,Passeriformes,100.00%,Turdidae,100.00%,Swainson's thrush,Catharus ustulatus,SWTH,99.28%





  Please visit our website for more information on the BirdVox project: [https://wp.nyu.edu/birdvox](https://wp.nyu.edu/birdvox)

  The main developer of BirdVoxDetect is Vincent Lostanlen, scientist at CNRS, the French national center for scientific research.



  For any questions or announcements related to BirdVoxDetect, please refer to our discussion group:
  [https://groups.google.com/g/birdvox](https://groups.google.com/g/birdvox)


  Please cite the following paper when using BirdVoxDetect in your work:

  **[Robust Sound Event Detection in Bioacoustic Sensor Networks](https://journals.plos.org/plosone/article/file?id=10.1371/journal.pone.0214168&type=printable)**<br/>
  Vincent Lostanlen, Justin Salamon, Andrew Farnsworth, Steve Kelling, and Juan Pablo Bello<br/>
  PLoS ONE 14(10): e0214168, 2019. DOI: https://doi.org/10.1371/journal.pone.0214168


  As of v0.4, species classification in BirdVoxDetect relies on a taxonomical neural network (TaxoNet), which is distributed as part of the BirdVoxClassify package. For more details on TaxoNet, please refer to:

  **[Chirping up the Right Tree: Incorporating Biological Taxonomies into Deep Bioacoustic Classifiers](https://www.justinsalamon.com/uploads/4/3/9/4/4394963/cramer_taxonet_icassp_2020.pdf)**<br/>
  Jason Cramer, Vincent Lostanlen, Andrew Farnsworth, Justin Salamon, and Juan Pablo Bello<br/>
  In IEEE International Conference on Acoustics, Speech, and Signal Processing (ICASSP), Barcelona, Spain, May 2020.


pkgId: 9c59ec01d0d4a248910592d129c61d7b14e33dffff0e4427ab2a3efd9081d0ad
name: python-birt-gd
arch: src
version: 0.1.47
epoch: 0
release: 1
summary: BIRT is an implementation of Beta3-irt using gradient descent.
url: https://github.com/Manuelfjr/birt-gd
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-birt-gd-0.1.47-1.src.rpm
checksum_type: sha256
description:
                          | Min      1Qt      Median   3Qt      Max      Std.Dev
          Ability         | 0.00010  0.22147  0.63389  0.73353  0.92040  0.33960
          Difficulty      | 0.01745  0.28047  0.63058  0.84190  0.98624  0.31635
          Discrimination  | 0.31464  1.28330  1.61493  2.22936  4.44645  1.02678


pkgId: f62f0f5eb8d012438a5b0d9c6f6833a5f5b3ad5df1a5a98a811ad01243de9fdf
name: python-bisHash
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A simple hashing algorithm library
url: https://github.com/michaelIldefonso/Hashing-Algorithm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bisHash-1.1.0-1.src.rpm
checksum_type: sha256
description:
  A simple hashing algorithm library for demonstration purposes.



  You can install it directly from GitHub:

  ```bash
  pip install bisHash


pkgId: 08ddbc00b71e6b6c4a06af41d4c9cadb46622f9045cfcc36c6e7124adfcc8b7b
name: python-biscuit-editor
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: A lightweight, fast, and extensible code editor with a growing community
url: https://pypi.org/project/biscuit-editor/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biscuit-editor-3.0.1-1.src.rpm
checksum_type: sha256
description:
  ![image](https://github.com/user-attachments/assets/a578d600-a4a8-4ce4-904d-4aa0e73fc124)

  Aesthetic, lightweight code editor with extension support. Draws inspiration from mainstream editors like VSC, Zed, and Vim. Hobby project.
  > - - - -  Check all extensions and their authors [`~extension repository`](https://tomlin7.github.io/biscuit-extensions/)
  > - - - -  Contributing/User guides, API reference [`~documentation`](https://tomlin7.github.io/biscuit)
  > - - - -  Scroll down to see list of all supported [`~features`](https://github.com/tomlin7/biscuit?tab=readme-ov-file#features)

  ![image](https://github.com/user-attachments/assets/3ff11be7-754b-4159-87bd-0cf48406821d)
  > Theme inspired by [`morhetz/gruvbox`](https://github.com/morhetz/gruvbox)



  Install the latest release from PyPI by running:
  ```bash
  > pip install biscuit-editor
  ```
  Quickly open up a project using **`biscuit path/to/src`** and start editing. See other [installation methods](https://tomlin7.github.io/biscuit/getting-started/installation/).



  - - - Please check the [docs](https://tomlin7.github.io/biscuit/getting-started/quick-start/) and [contributing guide](https://github.com/tomlin7/Biscuit/blob/main/CONTRIBUTING.md) for a quick tour of the project structure and to set up the environment.
  - - - To make a new extension, read the [extension docs](https://github.com/tomlin7/biscuit-extensions)

  <a href="https://github.com/tomlin7/biscuit/graphs/contributors">
    <img src="https://opencollective.com/biscuit/contributors.svg" />
  </a><br>





  - code completions
  - hover
  - symbol outline (palette `Ctrl + J`)
  - symbol references
  - goto-definition/declaration

  More language servers are registered through extensions, see the [Rust](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/rust.py), [Typescript](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/javascript_typescript.py) extensions
  for reference. Feel free to open issues/discussions for help!

  ![peek](https://github.com/user-attachments/assets/16350a91-8d87-422d-b779-1db21033e979)

  <table>
      <tr>
          <img src=https://github.com/tomlin7/biscuit/assets/70792552/36589a2d-8f5f-4196-bc88-5b1800492076 height=270>
      </tr>
      <tr>
          <img src=https://github.com/tomlin7/biscuit/assets/70792552/68a26ccb-b309-4c21-b75e-3e5cf5fa6500 height=270>
      </tr><br>
      <figcaption>
          <a href=https://github.com/tomlin7/biscuit/blob/main/src/biscuit/settings/theme/vscdark.py><code>Biscuit VS dark theme</code></a>
      </figcaption>
  </table>



  - breakpoints in multiple files
  - variable inspection
  - modify variables at runtime
  - call stack

  Built-in Python debugger is available right now, more debuggers can be registered through extensions.
  - TODO: Debugger Adapter Protocol support, [DAP client](https://github.com/tomlin7/debug-adapter-client) integration

  ![breakpoint](https://github.com/user-attachments/assets/a34d6e59-4743-43ee-a1a1-b7a5eac589bf)


  - Diff viewer
  - Git operations GUI-fied (push, pull, commit, stage, unstage, switch branches)
  - Clone repositories within editor, and open them up
  - View GitHub issues/pr within editor (NOTE: will be converted to an extension)

  ![image](https://github.com/user-attachments/assets/c23c0338-7c19-4636-831e-3d97b539df46)
  ![image](https://github.com/user-attachments/assets/41cdbe73-4b24-4502-95f6-fcc17a2002be)



  - Attach files for context in chat
  - Generate terminal commands within integrated terminal (use `# prompt` in terminal, then accept/decline response)
  - Run local LLMs with Ollama extension
  - Google Gemini built-in support (key)

  More providers can be added with extensions, see [ollama extension](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/ollama.py) for reference.

  ![Assistant](https://github.com/user-attachments/assets/898d5223-87c2-4368-acd2-8ae060daab70)


  - regex support
  - file preview, occurrence count, etc
  - search within editors with find-replace widget

  ![image](https://github.com/user-attachments/assets/6dd1baa2-c89c-437d-9613-00e72fa9e009)


  - **Integrated Terminals**
    - Set up and store run command for each editor for ease
    - Use `# prompt here...` commands to generate commands with assistant (key)
    - Multiple terminals can be opened (Built in support for powershell, bash, cmd, python REPL, etc.)

    ![image](https://github.com/user-attachments/assets/733fbd70-8377-4907-92fa-83e0dcad9368)

  - **Extension center**
    - Install and manage all available extensions
    - Filter all installed extensions
    - Search for extensions

    ![image](https://github.com/user-attachments/assets/9f6d67f2-b00f-43e6-804a-8f66e03b8183)

  - Split-pane **Markdown** editor, HTML renderer
    - Split-pane editing
    - Syntax highlighting support
    - TODO: CSS support for HTML editor

    ![image](https://github.com/user-attachments/assets/ac086e4d-023e-4dd1-ae26-96271d900656)

  - Rich Command palette (commands added to [commands.py](https://github.com/tomlin7/biscuit/blob/main/src/biscuit/commands.py) are automatically made available)
  - **Drag and drop** to open files or folders in Biscuit
  - Built-in [editorconfig](https://editorconfig.org/) support
  - Toggle relative line numbering
  - Formatter extensions support
    - See [black](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/black.py), [Ruff](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/ruff.py), [YAPF](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/yapf.py), [autopep8](https://github.com/tomlin7/biscuit-extensions/blob/main/extensions/autopep8.py) for reference.

    ![image](https://github.com/user-attachments/assets/73a86fb6-89f8-4cd9-8552-5c1fb9c2e3b0)




  Biscuit uses the MIT License. For more information, see [LICENSE.md](https://github.com/tomlin7/Biscuit/blob/main/LICENSE.md).

  <a href=https://github.com/tomlin7/Biscuit/actions/workflows/nightly.yml><img src="https://img.shields.io/github/actions/workflow/status/tomlin7/biscuit/nightly.yml"></a>
  <img alt="Project License" src="https://img.shields.io/github/license/tomlin7/Biscuit">
  <a href=https://github.com/tomlin7/Biscuit/releases> <img alt="Download Latest" src="https://img.shields.io/github/v/release/tomlin7/biscuit"></a>
  <img alt="GitHub closed pull requests" src="https://img.shields.io/github/issues-pr-closed-raw/tomlin7/Biscuit">


  ![image](https://github.com/user-attachments/assets/0df70dbd-b4e2-46ae-9715-045bdf85ed13)


pkgId: 41ee18c6baab1c8ba4b74d67c558b060876c069f9b19a5f56d98a02cb8f11266
name: python-biseau
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: Draw graphs using Answer Set Programming
url: https://gitlab.inria.fr/lbourneu/biseau
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biseau-0.0.20-1.src.rpm
checksum_type: sha256
description:
  Build by Input Some Easy ASP from User.

  Helps the exploration of formal structures by using ASP as a DSL for drawing graphs.
  For a Graphical User Interface, see the [biseau-gui](https://gitlab.inria.fr/lbourneu/biseau-gui) package.


  For the initial version of biseau published in the
  [FCA4AI'18 workshop](https://fca4ai.hse.ru/2018) at IJCAI,
  see [the archived repository biseau-initial](https://gitlab.inria.fr/lbourneu/biseau-initial)




  Now, you may want to read about:

  - [visualization details](doc/user-doc.mkd#visualization-principles), that explains the theory behind the visualization itself.
  - [visualization DSL](doc/user-doc.mkd#asp-to-dot), that explains which atoms produces which effect in visualization.
  - [scripting](doc/user-doc.mkd#scripting), that allow you to implement new behavior for biseau.



  Currently under development.





  See [user documentation](doc/user-doc.mkd#installation) for details,
  but in short, you need [clingo](https://potassco.org/clingo/),
  [graphviz](http://graphviz.org/) and `make install-deps`.

  Biseau and its gui are packaged, so if you already have clingo and graphviz, you should be good with:

      pip install biseau biseau-gui



  See [user documentation](doc/user-doc.mkd#basic-usage) for details.
  See [`Makefile`](Makefile) for various recipes.
  Running biseau can be done using the following commands:

      python -m biseau gui     # run the Graphical User Interface (if biseau-gui is installed)
      python -m biseau         # run the Command Line Interface
      python -m biseau --help  # get help for the CLI




  To save you from some kind of attacks, Pillow may prevent you to create large images. To fix that, you can use something like:

      from PIL import Image
      Image.MAX_IMAGE_PIXELS = 20000  # or None, if you are feeling adventurous


pkgId: 6986a9c7bd86796b267ad7dcde9a3f842770b4d26f3ff091a137db2650630cef
name: python-bisect-scanner
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Scan for balance history
url: https://github.com/Gaunt/bisect_scanner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bisect-scanner-0.2.5-1.src.rpm
checksum_type: sha256
description:
  Determine crypro accounts balance history using bisection algorithm



  ```python
  >>> from bisect_scanner import EtherScanner, EthereumERC20Scanner

  >>> account = '0x790370ff5045bCeCc2161f0913302FCCC7Ee256d'
  >>> ETHEREUM_W3_URL = '...' # url for an archive node web3 or a web3 client instance
  >>> scanner = EtherScanner(w3=ETHEREUM_W3_URL)
  >>> [*scanner.balance_history(account='0x790370ff5045bCeCc2161f0913302FCCC7Ee256d')]
  [(0, 0.0),
   (11503731, 0.005),
   (12103372, 0.015),
   (12107610, 0.009),
   (12425773, 0.0)]

  >>> scanner = EthereumERC20Scanner(w3=ETHEREUM_W3_URL,
  	contract_address='0x0258f474786ddfd37abce6df6bbb1dd5dfc4434a')
  >>> [*scanner.balance_history(account='0x790370ff5045bCeCc2161f0913302FCCC7Ee256d')]
  [(10939214, 0.0), (11503719, 200.0), (12107610, 0.0)]
  ```



  bisect_scanner is available on PyPI:

  ```console
  $ pip install bisect-scanner
  ```




  ```console
  $ python -m bisect_scanner --help
  usage: python -m bisecect_scanner [-h] --account ACCOUNT
                                    [--contract_address CONTRACT_ADDRESS]
                                    [--scan_step SCAN_STEP]
                                    [--precission PRECISSION]
                                    [--interpolation_step INTERPOLATION_STEP]
                                    [--start_block START_BLOCK]
                                    [--end_block END_BLOCK] [--polygon]
                                    [--ethereum] [--fake]

  Outputs account balance history on stdout in the csv format,Example: python -m
  bisect_scanner --account=0xCD6909C37CCEA877a5c8e9a3ffd69d9D9943409F

  optional arguments:
    -h, --help            show this help message and exit
    --account ACCOUNT     address
    --contract_address CONTRACT_ADDRESS
                          ERC20 contract address
    --scan_step SCAN_STEP
                          scan step
    --precission PRECISSION
                          precission
    --interpolation_step INTERPOLATION_STEP
                          interpolation step
    --start_block START_BLOCK
                          Start Block
    --end_block END_BLOCK
                          End Block
    --polygon             Polygon (MATIC native Token)
    --ethereum            Ethereum (default)
    --fake                fake chain for testing purposes only
  ```




  ```console
  $ python -m bisect_scanner --account='0x790370ff5045bCeCc2161f0913302FCCC7Ee256d'
  block,balance
  0,0.0
  11503731,0.005
  12103372,0.015
  12107610,0.009
  12425773,0.0
  ```

  <!-- ![](assets/peek_2_fast.gif) -->




  Configuration can be stored in `~/.config/bisect_scanner.ini` file



  ```
  [node_urls]
  W3_URL=archive_node_url_for_general_w3scanner
  POLYGON_URL=argive_node_url_for_polygonscanner
  ETHEREUM_URL=archive_node_url_for_etherscanner
  ```



  `bisect_scanner` was written by `Karel Novak`.


pkgId: 1674fdea1c1b892dce088c9cb5a14e0d056b719b6d5d713dbb4888dc3078cd1e
name: python-bismuth-mypy
arch: src
version: 1.11.2b3
epoch: 0
release: 1
summary: Optional static typing for Python
url: https://www.mypy-lang.org/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bismuth-mypy-1.11.2b3-1.src.rpm
checksum_type: sha256
description:
  Add type annotations to your Python programs, and use mypy to type
  check them.  Mypy is essentially a Python linter on steroids, and it
  can catch many programming errors by analyzing your program, without
  actually having to run it.  Mypy has a powerful type system with
  features such as type inference, gradual typing, generics and union
  types.


pkgId: 89a844751f3b4c20b329ddc69290c801e04d568508da9fdfbde180ea16b6c2fb
name: python-bisque-metadoc
arch: src
version: 0.6.4.12
epoch: 0
release: 1
summary: Bisque Metadoc
url: https://pypi.org/project/bisque-metadoc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bisque-metadoc-0.6.4.12-1.src.rpm
checksum_type: sha256
description:
  Representation of hierarchical documents with various "rendering" and query options.
  For doc communication between server/clients.






  `pip install bisque-metadoc`





  * [Metadoc](https://viqi.gitlab.io/viqi-common/viqi_metadoc/)


pkgId: 647e948db262479a2d3615bd0e3c8689267a8c033b5642a17f4c81ade08643e2
name: python-bistiming
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A logging-friendly stopwatch and profiling tool for Python.
url: https://bistiming.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bistiming-0.5.0-1.src.rpm
checksum_type: sha256
description:
  A logging-friendly stopwatch and profiling tool for Python.
  When we search the stopwatch or timing module for Python on the internet, we can find a
  lot of code snippets, but none of them is powerful or convenient enough to do our daily
  jobs.
  BisTiming aims at implementing all the missing functions in those code snippets and
  prevents us from reinventing the wheel.
  It is very useful when we want to log something with some timing information or
  optimize the performance of our code.
  This package is tested with Python 2.7, 3.5, 3.6 and 3.7, but might also work in other
  Python versions.


pkgId: 3de3afc21601c75f2ddca59a6269f102f400aa1365436849fa4028173c49a9e4
name: python-bistiming
arch: src
version: 0.5.1.post0
epoch: 0
release: 1
summary: A logging-friendly stopwatch and profiling tool for Python.
url: https://bistiming.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bistiming-0.5.1.post0-1.src.rpm
checksum_type: sha256
description:
  A logging-friendly stopwatch and profiling tool for Python.
  When we search the stopwatch or timing module for Python on the internet, we can find a
  lot of code snippets, but none of them is powerful or convenient enough to do our daily
  jobs.
  BisTiming aims at implementing all the missing functions in those code snippets and
  prevents us from reinventing the wheel.
  It is very useful when we want to log something with some timing information or
  optimize the performance of our code.
  This package is tested with Python 3.8 to 3.14, but might also work in other
  Python versions.


pkgId: 854818b4d7b42f7396e96989ad7138718fbc5ed33b198a317ff523cd9985d0f3
name: python-bistring
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Bidirectionally transformed strings
url: https://github.com/microsoft/bistring
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bistring-0.5.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI version|
  The bistring library provides non-destructive versions of common string processing operations like normalization, case folding, and find/replace.
  Each bistring remembers the original string, and how its substrings map to substrings of the modified version.
  For example:
      >>> from bistring import bistr
      >>> s = bistr('𝕿𝖍𝖊 𝖖𝖚𝖎𝖈𝖐, 𝖇𝖗𝖔𝖜𝖓 🦊 𝖏𝖚𝖒𝖕𝖘 𝖔𝖛𝖊𝖗 𝖙𝖍𝖊 𝖑𝖆𝖟𝖞 🐶')
      >>> s = s.normalize('NFKD')     # Unicode normalization
      >>> s = s.casefold()            # Case-insensitivity
      >>> s = s.replace('🦊', 'fox')  # Replace emoji with text
      >>> s = s.replace('🐶', 'dog')
      >>> s = s.sub(r'[^\w\s]+', '')  # Strip everything but letters and spaces
      >>> s = s[:19]                  # Extract a substring
      >>> s.modified                  # The modified substring, after changes
      'the quick brown fox'
      >>> s.original                  # The original substring, before changes
      '𝕿𝖍𝖊 𝖖𝖚𝖎𝖈𝖐, 𝖇𝖗𝖔𝖜𝖓 🦊'
  This allows you to perform very aggressive text processing completely invisibly.


pkgId: 3ff23679e121bca4e853c73e2aea1b50849387d20b52139cc1a89fb77b669a86
name: python-bitalign
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Shift some bits and see how they line up best.
url: https://github.com/sweeneyde/bitalign
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitalign-0.4.0-1.src.rpm
checksum_type: sha256
description:
  *Given two strings of bits, find how to best align them so that they have the most bits in common.*





  The following snippets show a conceptual string of 16 bits `A = "0001001011111111"`
  needs to shifted to the right by 5 in order to best line up with
  the string of 16 bits `B = "1111100010010111"`, at
  which point they have 11 bits in common:

  ```
  A =      0001001011111111
  B = 1111100010010111
  ```

  The only differences are how we decide to encode the bits into a list of integer.

  ```pycon
  >>> from bitalign import *

  >>> # We can can treat bytes objects like b'\x12\xff' as bit arrays
  >>> A = bytes([0b0001_0010, 0b1111_1111])
  >>> B = bytes([0b1111_1000, 0b1001_0111])
  >>> bitalign_8_msb(A, B)
  (5, 11)

  >>> # Reversing the bits in each byte --> use "lsb" method instead
  >>> A = bytes([0b0100_1000, 0b1111_1111])
  >>> B = bytes([0b0001_1111, 0b1110_1001])
  >>> bitalign_8_lsb(A, B)
  (5, 11)

  >>> # numpy arrays also work, just make sure they have an appropriate dtype.
  >>> import numpy as np
  >>> A = np.array([0b0001001011111111], dtype=np.uint16)
  >>> B = np.array([0b1111100010010111], dtype=np.uint16)
  >>> bitalign_16_msb(A, B)
  (5, 11)

  >>> # Reverse bits in each uint64 --> use "lsb" method instead
  >>> A = np.array([0b1111111101001000], dtype=np.uint16)
  >>> B = np.array([0b1110100100011111], dtype=np.uint16)
  >>> bitalign_16_lsb(A, B)
  (5, 11)

  >>> # Works on general pairs of c-contiguous buffer objects
  >>> # numpy.array, array.array, bytes, bytearray, memoryview, etc.
  >>> import array
  >>> A = array.array('H', [0b0001001011111111])
  >>> B = array.array('H', [0b1111100010010111])
  >>> bitalign_16_msb(A, B)
  (5, 11)
  ```



  This `bitalign` package exposes 8 methods:

  ```python
  from bitalign import (
      bitalign_8_lsb,
      bitalign_16_lsb,
      bitalign_32_lsb,
      bitalign_64_lsb,
      bitalign_8_msb,
      bitalign_16_msb,
      bitalign_32_msb,
      bitalign_64_msb,
  )
  ```

  ```
      bitalign_#_?sb(arr1, arr2) --> (shift_by, num_common_bits);

      Return a tuple (x, y) such that when arr1 is shifted by x bits,
      the number of bits in common between arr1 and arr2 is y.

      Positive shifts indicate that arr1 needs to be shifted toward the back:

          arr1 =                    -->  0001001011111111  -->
          arr2 =                    1111100010010111
          gives (shift_by=5, num_common_bits=11)

      Negative shifts indicate that arr1 needs to be shifted toward the front:

          arr1 =          <--  1111100010010111  <--
          arr2 =                    0001001011111111
          gives (shift_by=-5, num_common_bits=11)

      The number (8, 16, 32, or 64) in the function name the number of bits
      that must be in each array entry.  'lsb'/'msb' indicates whether the
      0th bit of each logical bit-array is to be stored in the least or most
      significant bit of arr[0].

      If more than one shift is optimal, the negative-most shift is used.
      If there are no bits in common (i.e., all zeros with all ones),
      then (-num_bits, 0) is returned.
  ```


pkgId: 7a6a4c36c837c67a53eba5b51f2f9e85d547377899359c8717456e3481f9d0c1
name: python-bitarray
arch: src
version: 2.9.2
epoch: 0
release: 1
summary: efficient arrays of booleans -- C extension
url: https://github.com/ilanschnell/bitarray
rpm_license: PSF
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitarray-2.9.2-1.src.rpm
checksum_type: sha256
description:
  This library provides an object type which efficiently represents an array
  of booleans.  Bitarrays are sequence types and behave very much like usual
  lists.  Eight bits are represented by one byte in a contiguous block of
  memory.  The user can select between two representations: little-endian
  and big-endian.  All functionality is implemented in C.
  Methods for accessing the machine representation are provided, including the
  ability to import and export buffers.  This allows creating bitarrays that
  are mapped to other objects, including memory-mapped files.


pkgId: 22d8aeb1d8d6a6e2b03801945945ec7527becbbaaa61ec27e1f10109c9d03837
name: python-bitbnspy
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/bitbns-official/bitbnspy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitbnspy-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  This project is designed to assist you make your own projects that interact with the Bitbns API. This project seeks to have complete API coverage and WebSockets


pkgId: f654e3a464cd51a94ef11c6f1db939abca4e38d1187c69e5117b744375fd8a69
name: python-bitbox02
arch: src
version: 6.3.0
epoch: 0
release: 1
summary: Python library for bitbox02 communication
url: https://github.com/digitalbitbox/bitbox02-firmware
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitbox02-6.3.0-1.src.rpm
checksum_type: sha256
description:
  This repository contains two packages

  * u2fhid
  * bitbox02



  This is a small package that contains read/write primitives for u2fhid devices such as the
  bitbox02.



  In this folder is the Python API for communicating with the BitBox02 device.

  The folder `generated` contains files generated by `python-protobuf`. Regenerate with `make`.


pkgId: 497d780b53d892dc5d40db36b08484d43e9773542fa318a6d393420824a4c250
name: python-bitbucket-cloud-client-foolishnekozzz
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: SDK for Bitbucket Cloud
url: https://github.com/foolishnekozzz/bitbucket-cloud-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitbucket-cloud-client-foolishnekozzz-1.0.2-1.src.rpm
checksum_type: sha256
description:
  python sdk for bitbucket cloud rest api




  ```bash
  pip install -i https://test.pypi.org/simple/ bitbucket-cloud-client-foolishnekozzz
  ```



  ```bash
  export BITBUCKET_WORKSPACE="neko"
  export BITBUCKET_USERNAME="neko"
  export BITBUCKET_PASSWORD="neko"
  ```

  ```python


  from bitbucket_cloud_client_foolishnekozzz import BitbucketWorkspace, BitbucketGroup, Member

  from os import environ

  workspace = BitbucketWorkspace(name=environ.get("BITBUCKET_WORKSPACE"))
  workspace.get_groups()


  default_group = BitbucketGroup(name="default", workspace=workspace)

  default_group.get_members()

  for i in default_group.members:
      print(i)
  ```


pkgId: 26a753d478252ebd70235fc175d0d572822f6ba1fb31e23e245f7ba47a7dbea8
name: python-bitbucket-pipeline-runner
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: Run a bitbucket pipeline locally
url: https://github.com/mathieu-lemay/pipeline-runner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitbucket-pipeline-runner-0.4.7-1.src.rpm
checksum_type: sha256
description:
  Tool to run Bitbucket Pipelines locally.


  The prefered way of installing pipeline-runner is with [pipx](https://pipx.pypa.io/stable/installation/)
  ```shell
  pipx install bitbucket-pipeline-runner
  ```


  To run a pipeline
  ```shell
  cd <project-directory>
  pipeline-runner run <pipeline-name>
  ```

  To list available pipelines
  ```shell
  cd <project-directory>
  pipeline-runner list
  ```


  bitbucket pipeline runner already sets all `BITBUCKET_*` environment variables in the step's run environment.
  It will also source any `.env` file in the current directory, for all project specific environment variables.


  Persistent data like artifacts generated from your pipelines and execution logs can be found in your user's data directory.

  On Linux:

      ${XDG_DATA_HOME:-~/.local/share}/pipeline-runner

  On macOS:

      ~/Library/Application Support/pipeline-runner


  Caches defined in your pipelines are stored in your user's cache directory. Unlike Bitbucket Pipelines, caches are always
  saved even if they already exists. This is subject to change in the future, to follow the behaviour of Bitbucket Pipelines.

  On Linux:

      ${XDG_CACHE_HOME:-~/.cache}/pipeline-runner

  On macOS:

      ~/Library/Caches/pipeline-runner

  Note: Docker cache is stored in a docker volume instead.


  | Feature               | Supported  | Note                                           |
  | --------------------- | :--------: | :--------------------------------------------: |
  | Variables             | ✅         |                                                |
  | Artifacts             | ✅         |                                                |
  | Docker Service        | ✅         |                                                |
  | Caches                | ✅         |                                                |
  | Custom Caches         | ✅         |                                                |
  | Private Runner Images | ✅         |                                                |
  | Pipes                 | ✅         |                                                |
  | OIDC                  | ❌         | Theoretically possible but way too impractical |


  A few features are available to help with debugging.


  Breakpoints, or pauses, can be added during the execution of a pipeline. To do so, add a `# pipeline-runner[breakpoint]` entry in `script` like so
  ```
      example_with_breakpoint:
        - step:
            name: Step with breakpoint
            script:
              - echo "do something"
              - # pipeline-runner[breakpoint]
              - echo "do something else"
  ```

  The execution will stop at the breakpoint to allow the user to check the state of the pipeline.


  By default, no cpu limits are enforced, meaning that the pipeline will run as fast as it can.
  You can mimick the cpu limits enforced by Bitbucket Pipelines with the `--cpu-limits`. This is
  useful to replicate more closely the speed at which a pipeline runs in the real thing.


pkgId: 79a2b7d4a274787d25cbcf961d51c016f144c15bf003072c58d5490050a4a5ed
name: python-bitbucket-pipes-toolkit
arch: src
version: 5.0.1
epoch: 0
release: 1
summary: This package contains various helpers for developing bitbucket pipelines pipes
url: https://bitbucket.org/bitbucketpipelines/bitbucket-pipes-toolkit
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitbucket-pipes-toolkit-5.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Coverage](https://bitbucket.org/bitbucketpipelines/bitbucket-pipes-toolkit/downloads/coverage.svg)
  This package contains various tools and helpers to make it more fun and easy for people to develop pipes. This includes improved colorized logging, shared data interface, array variables helpers and more.

rpm_license:
  Copyright @ 2019 Atlassian Pty Ltd  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: 9aa0bae206fd21557c3f141d2f99a75db64ce6b45f3811618179f2802075e367
name: python-bitbucket-python
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: API wrapper for Bitbucket written in Python
url: https://pypi.org/project/bitbucket-python/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitbucket-python-0.3.2-1.src.rpm
checksum_type: sha256
description:
  bitbucket-python is an API wrapper for Bitbucket written in Python


  ```
  pip install bitbucket-python
  ```



  ```python
  from bitbucket.client import Client
  from bitbucket import AsyncClient

  client = Client('EMAIL', 'PASSWORD')


  client = Client('EMAIL', 'PASSWORD', 'Owner')


  async with AsyncClient('EMAIL', 'PASSWORD') as client:
      ...

  ```



  Get user information
  ```
  response = client.get_user()
  ```

  Get account privileges for repositories
  ```
  response = client.get_privileges()
  ```

  Get repositories
  ```
  response = client.get_repositories()
  ```

  Get repository
  ```
  response = client.get_repository('REPOSITORY_SLUG')
  ```

  Post repository
  ```
  response = client.create_repository(data, params, repositoryName, teamName)
  ```

  Get branches for repository
  ```
  response = client.get_repository_branches('REPOSITORY_SLUG')
  ```

  Get tags for repository
  ```
  response = client.get_repository_tags('REPOSITORY_SLUG')
  ```

  Get commits for a repository
  ```
  response = client.get_repository_commits('REPOSITORY_SLUG')
  ```

  Get components for repository
  ```
  response = client.get_repository_components('REPOSITORY_SLUG')
  ```

  Get milestones for repository
  ```
  response = client.get_repository_milestones('REPOSITORY_SLUG')
  ```

  Get versions for repository
  ```
  response = client.get_repository_versions('REPOSITORY_SLUG')
  ```

  Create issue
  ```
  data = {..DATA..}
  response = client.create_issue('REPOSITORY_SLUG', data)
  ```

  Get all issues
  ```
  response = client.get_issues('REPOSITORY_SLUG')
  ```

  Get issue
  ```
  response = client.get_issue('REPOSITORY_SLUG', 'ISSUE_ID')
  ```

  Delete issue
  ```
  response = client.delete_issue('REPOSITORY_SLUG', 'ISSUE_ID')
  ```



  Create webhook
  ```
  data = {
      "description": "Webhook",
      "url": "http://mywebsite.com",
      "active": True,
      "events": [
          "repo:push",
          "issue:created",
          "issue:updated"
      ]
  }
  response = client.create_webhook('REPOSITORY_SLUG', data)
  ```

  Get all webhooks
  ```
  response = client.get_webhooks('REPOSITORY_SLUG')
  ```

  Get webhook
  ```
  response = client.get_webhook('REPOSITORY_SLUG', 'WEBHOOK_ID')
  ```

  Delete webhook
  ```
  response = client.delete_webhook('REPOSITORY_SLUG', 'WEBHOOK_ID')
  ```





  The `all_pages` method is a helper function that makes it easy to retrieve all items from an API methods that uses pagination (see https://developer.atlassian.com/cloud/bitbucket/rest/intro/#pagination).

  ```python
  client = Client()

  items = list(client.all_pages(client.get_repositories))
  ```

  Note that the `all_pages` method uses a generator to return the results.




  - requests
  - [httpx](https://github.com/encode/httpx/)


pkgId: c2f8e4372ebe5fa034a3fae11035ffaef4043eebc1ce5b7dd0ee02883e7ff871
name: python-bitcart
arch: src
version: 1.16.0.0
epoch: 0
release: 1
summary: Bitcart coins support library
url: https://github.com/bitcart/bitcart-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcart-1.16.0.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/bitcart/bitcart-sdk.svg?style=svg)](https://circleci.com/gh/bitcart/bitcart-sdk)
  [![Codecov](https://img.shields.io/codecov/c/github/bitcart/bitcart-sdk?style=flat-square)](https://codecov.io/gh/bitcart/bitcart-sdk)
  [![PyPI version](https://img.shields.io/pypi/v/bitcart.svg?style=flat-square)](https://pypi.python.org/pypi/bitcart/)
  [![Read the Docs](https://img.shields.io/readthedocs/bitcart-sdk?style=flat-square)](https://sdk.bitcart.ai)

  This is a client library(wrapper) around Bitcart daemon. It is used to simplify common commands.
  Coins support(⚡ means lightning is supported):

  - Bitcoin (⚡)
  - Bitcoin Cash
  - Monero
  - Ethereum
  - Binance coin (BNB)
  - SmartBCH
  - Polygon (MATIC)
  - Tron (TRX)
  - Ergon
  - Litecoin (⚡)
  - Globalboost (⚡)
  - Groestlcoin (⚡)

  Main focus is Bitcoin.

  This library supports both asynchronous and synchronous usages.

  You can call it's methods synchronously, like so:

  ```python
  print(btc.help())
  ```

  Or you can await it's methods when using from async functions:

  ```python
  async def main():
      print(await btc.help())
  ```

  Async callback functions for `@btc.on` are supported.

  For more information [Read the Docs](https://sdk.bitcart.ai)



  We follow a custom variant of semver:

  `major.minor.feature.bugfix`

  Where `major` is changed not frequently, and means significant changes to the SDK

  `minor` means breaking changes

  `feature` means adding new features without breaking existing APIs

  `bugfix` means fixing bugs without breaking existing APIs



  See [CONTRIBUTING.md](CONTRIBUTING.md).



  Copyright (C) 2019 MrNaif2018

  Licensed under the [MIT license](LICENSE)


pkgId: 846b20f6f0f725ba6c3e929dc946bc2bdc959d422cee4b1d1c3a4174fd49418c
name: python-bitcoin-lite
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A lightweight Bitcoin transaction system using Cython
url: https://github.com/danymukesha/bitcoin-lite
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-lite-0.1.4-1.src.rpm
checksum_type: sha256
description:
      Mean transaction amount: {metrics.mean_amount:.2f}
      Standard deviation: {metrics.std_dev:.2f}
      Transaction density: {metrics.transaction_density:.4f}
      Network load: {metrics.network_load:.2f}
      System capacity: {metrics.system_capacity:.2f} tx/s
      """)
  ```
  Dashboard example for analystical aspects of the transaction system:
  ```python
  if __name__ == "__main__":
      from database import TransactionDatabase
      
      db = TransactionDatabase()
      generator = AnalyticsDataGenerator(db)
      
      dashboard_data = generator.generate_dashboard_data()
      print(dashboard_data)
      const dashboardData = JSON.parse(data);
      <Analytics data={dashboardData} />
  ```
  ![dashboard](https://github.com/user-attachments/assets/7a48d485-0001-45cf-a5c7-bf38998caeec)

  1. Implementation of advanced statistical models for transaction analysis
  2. Development of predictive algorithms for load balancing
  3. Integration of machine learning for anomaly detection
  4. Enhancement of performance metrics and benchmarking methodologies

  The demonstration and models presented above here can be used for:
  1. System optimization
  2. Performance prediction
  3. Capacity planning
  4. Security analysis
  5. Scalability assessment
  The models can even be extended for more complex scenarios and integrated with
  additional cryptocurrency features as needed.

  Contributions to the Bitcoin-Lite package are welcome! If you have ideas for additional features,
  optimizations, or examples, feel free to submit a pull request or open an issue in the GitHub repository.

  This package will be open-source and is not under any license (i.e. you can fork it, copy and modify it as you wish).


pkgId: 9acaa79b431e2f1a91d4cb77994246aaba585a07bcd49f675551b0c61f2e7f36
name: python-bitcoin-nostr-chat
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A Nostr Chat with participant discovery
url: https://github.com/andreasgriffin/bitcoin-nostr-chat
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-nostr-chat-0.4.1-1.src.rpm
checksum_type: sha256
description:
  All users know a shared secret (like a bitcoin wallet descriptor). This allows them to find each other.
    * Even if this shared secret leaks, the attacker can only spam the discovery option, the actual chats stay secure

  The actual single and group chats are based on a newly generated secret keys for each participant.
    * Each participant has to be manually accepted to be added to the group chat
    * Chats with participants use NIP17 and group messages are simply NIP17 messages to each participant

  Export and restoring of the nsec and with it restoration of all messages of the relays


pkgId: b182b3221383edaffa77a0eafa0c295485faee577ac372cee3e8482f664fe303
name: python-bitcoin-qr-tools
arch: src
version: 0.14.11
epoch: 0
release: 1
summary: Python bitcoin qr reader and generator
url: https://github.com/andreasgriffin/bitcoin-qrreader
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-qr-tools-0.14.11-1.src.rpm
checksum_type: sha256
description:
  * `BitcoinVideoWidget` recognizes (and classifies)  **blazingly fast**
    * Addresses  (also BIP21 with amount)
    * Transactions (also base43 electrum encoding)
    * PSBT
    * Xpub
    * Descriptor
    * Multipath Descriptor (like Sparrow)
    * Partial descriptors (Specter DIY) (finger print , derivation, xpub)
    * TxId
    * Wallet Export Infos (Sparrow Format, Coldcard Sparrow QR format, Specter DIY, ...)
    * Animated QR Codes (BBQR)
    * Animated QR Codes ([UR](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-005-ur.md)) (Transactions, Descriptors, Jade Wallet Export)
    * Animated QR Codes (Specter)
  * Recognizes (and classifies)  **blazingly fast**
  * QR Code generation via  `Data.generate_fragments_for_qr()`
  * QR Code Widgets, via the widgets `QRCodeWidget`,  `QRCodeWidgetSVG`



  Run the demo with

  ```
  python demo_reader.py
  ```



  ![screenshot](docs/bad-light.png)



  ![screenshot](docs/enhanced.png)





  ```shell
  pip install bitcoin_qr_tools
  ```



  * Setup poetry and install dependencies

    ```sh
    curl -sSL https://install.python-poetry.org | python3 -  # see https://python-poetry.org/docs/master/#installing-with-the-official-installer
    poetry config virtualenvs.in-project true
    poetry install
    ```

  * Run

    ```sh
    poetry shell
    python -m bitcoin_qr_tools
    ```



  The python files in *bitcoin_qr_tools*  are under the [GPL3](LICENSE).

  The folder *bitcoin_qr_tools/ur* is from https://github.com/Foundation-Devices/foundation-ur-py  and under   [BSD-2-Clause Plus Patent License](ur/LICENSE).

  The folder *bitcoin_qr_tools/urtypes* from https://github.com/selfcustody/urtypes  is under  [MIT](urtypes/LICENSE.md).


pkgId: bc947646a5841fba25ab5ca71ac5a9b15459b89abaf2389ed7a56aca19120630
name: python-bitcoin-qr-tools
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Python bitcoin qr reader and generator
url: https://github.com/andreasgriffin/bitcoin-qrreader
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-qr-tools-0.15.0-1.src.rpm
checksum_type: sha256
description:
  * `BitcoinVideoWidget` recognizes (and classifies)  **blazingly fast**
    * Addresses  (also BIP21 with amount)
    * Transactions (also base43 electrum encoding)
    * PSBT
    * Xpub
    * Descriptor
    * Multipath Descriptor (like Sparrow)
    * Partial descriptors (Specter DIY) (finger print , derivation, xpub)
    * TxId
    * Wallet Export Infos (Sparrow Format, Coldcard Sparrow QR format, Specter DIY, ...)
    * Animated QR Codes (BBQR)
    * Animated QR Codes ([UR](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-005-ur.md)) (Transactions, Descriptors, Jade Wallet Export)
    * Animated QR Codes (Specter)
    * Animated QR Codes (Foundation Passport)
  * Recognizes (and classifies)  **blazingly fast**
  * QR Code generation via  `UnifiedEncoder.generate_fragments_for_qr()`
  * QR Code Widgets, via the widgets `QRCodeWidget`,  `QRCodeWidgetSVG`



  Run the demo with

  ```
  python demo_reader.py
  ```



  ![screenshot](docs/bad-light.png)



  ![screenshot](docs/enhanced.png)





  ```shell
  pip install bitcoin_qr_tools
  ```



  * Setup poetry and install dependencies

    ```sh
    curl -sSL https://install.python-poetry.org | python3 -  # see https://python-poetry.org/docs/master/#installing-with-the-official-installer
    poetry config virtualenvs.in-project true
    poetry install
    ```

  * Run

    ```sh
    poetry shell
    python -m bitcoin_qr_tools
    ```



  The python files in *bitcoin_qr_tools*  are under the [GPL3](LICENSE).

  The folder *bitcoin_qr_tools/ur* is from https://github.com/Foundation-Devices/foundation-ur-py  and under   [BSD-2-Clause Plus Patent License](ur/LICENSE).

  The folder *bitcoin_qr_tools/urtypes* from https://github.com/selfcustody/urtypes  is under  [MIT](urtypes/LICENSE.md).


pkgId: 84d5fb85919d915955e0e1081013f3033f47ddc9d039a9db104961ae87984a54
name: python-bitcoin-usb
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Wrapper around hwi, such that one can sign bdk PSBTs directly
url: https://github.com/andreasgriffin/bitcoin-usb
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-usb-0.6.0-1.src.rpm
checksum_type: sha256
description:
  * This provides an abstraction layer ontop of hwi, such that only bdk is needed from the outside
  * Currently supported are
    - Coldcard
    - Bitbox02
    - Jade


  * It also provides
    - AddressTypes, which are the commonly used bitcoin output descriptor templates
    - seed_tools.derive_spk_provider  to derive xpubs from seeds for all AddressTypes  (bdk does not support multisig templates currently https://github.com/bitcoindevkit/bdk/issues/1020)
    - SoftwareSigner which can sign single and multisig PSBTs, this doesn't do any security checks, so only use it on testnet
    - HWIQuick to list the connected devices without the need to unlock them




  Run the demo with

  ```
  python demo.py
  ```




  Run tests

  ```
  python -m pytest -vvv  --log-cli-level=0
  ```



  * For xpub derivation bip_utils is used
  * For signing a psbt python-bitcointx is used








  ```shell
  pip install bitcoin_usb
  ```





  * Install  requirements:

  ```shell
  poetry install
  ```

  * Automatic commit formatting

  ```shell
  pip install pre-commit
  pre-commit install
  ```


  * Run the precommit manually for debugging

  ```shell
  pre-commit run --all-files
  ```


pkgId: 586ab19b18232f88f96df6c5278f8a0128059b487a22371d125ab8a8ca52f6e7
name: python-bitcoin-utils
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Bitcoin utility functions
url: https://github.com/karask/python-bitcoin-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-utils-0.7.1-1.src.rpm
checksum_type: sha256
description:
  This is a bitcoin library that provides tools/utilities to interact with the Bitcoin network. One of the primary goals of the library is to explain the low-level details of Bitcoin. The code is easy to read and properly documented explaining in detail all the thorny aspects of the implementation. It is a low-level library which assumes some high-level understanding of how Bitcoin works. In the future this might change.
  This is an early version of the library (v0.7.1) and currently, it supports private/public keys, all type of addresses and creation of any transaction, incl. segwit and taproot, with all SIGHASH types. All script op codes are included. Block parsing is also handled so you can read raw blocks directly. Extra functionality will be added continuously and the documentation will be improved as the work progresses.
  The API documentation can be build with Sphinx but is also available as a PDF for convenience. One can currently use the library for experimenting and learning the inner workings of Bitcoin. It is not meant for production yet and parts of the API might be updated with new versions.
  Complementary to this library is a CC BY-SA 4.0 licensed `Bitcoin programming book <https://github.com/karask/bitcoin-textbook>`_.


pkgId: 10d43871fb280febed77ac55fa43c4576ba10f661832a2105408f1d4227a21ec
name: python-bitcoin-value
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: A module to fetch the latest value of Bitcoin in different currencies.
url: https://github.com/dewittethomas/bitcoin-value
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoin-value-1.6.0-1.src.rpm
checksum_type: sha256
description:
  A Python module to fetch the latest value of Bitcoin in different currencies.

  [![PyPi Version](https://img.shields.io/pypi/v/bitcoin-value.svg)](https://pypi.org/project/bitcoin-value/)
  [![MIT License](https://img.shields.io/pypi/l/bitcoin-value.svg)](https://github.com/dewittethomas/bitcoin-value/blob/master/LICENSE)



  - [Installation](#installation)
  - [Usage](#usage)
    - [Getting Bitcoin Value](#getting-bitcoin-value)
  - [Contributing](#contributing)
  - [License](#license)



  You can install the `bitcoin-value` module using pip:

  ```bash
  pip install bitcoin-value
  ```





  You can use this module to get the current value of Bitcoin in various currencies. Here's an example of how to use it:

  ```python
  from bitcoin_value import currency


  bitcoin_value = currency("USD")


  print(f"1 BTC is equivalent to {bitcoin_value} USD")
  ```



  Contributions to this project are welcome. If you have any improvements or bug fixes, please submit a pull request.



  This project is licensed under the MIT License.


pkgId: c23a7e88147ebbe9f79719c247437e07700b76fe247cdcbb8eea127a081285c7
name: python-bitcoinaddress
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A simple Bitcoin address generator
url: https://github.com/fortesp/bitcoinaddress
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoinaddress-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/github/v/release/fortesp/bitcoinaddress)](https://github.com/fortesp/bitcoinaddress)
  [![](https://img.shields.io/github/stars/fortesp/bitcoinaddress.svg)](https://github.com/fortesp/bitcoinaddress)
  [![](https://img.shields.io/github/issues/fortesp/bitcoinaddress)](https://github.com/fortesp/bitcoinaddress)
  [![](https://img.shields.io/github/license/fortesp/bitcoinaddress?style)](https://github.com/fortesp/bitcoinaddress)



  This is a simple Bitcoin non-deterministic wallet address generator coded in Python 3. It generates a Private Key in different
  formats (hex, wif and compressed wif) and corresponding Public Addresses, raw, P2WPKH addresses starting with prefix 1, P2SH addresses
  starting with prefix 3 as part of Segwit soft fork and Bech32 addresses with prefix bc1 P2WPKH and P2WSH.



  ```
  pip install bitcoinaddress
  ```





  ```python
  from bitcoinaddress import Wallet

  wallet = Wallet()
  print(wallet)
  ```



  ```
  Private Key HEX: 03902e4f09664bc177fe4e090dcd9906b432b50f15fb6151984475c1c75c35b6
  Private Key WIF: 5HqrbgkWPqBy6dvCE7FoUiMuiCfFPRdtRsyi6NuCM2np8qBZxq5
  Private Key WIF compressed: KwLdv6T2jmhQbswnYrcL9KZHerTpVyjozp1JNjfP5QuD3GchCwCc

  Public Key: 04c5389a31ce6149c28ba20d14db8540b2319e5a65000a2919fbf7a6296e7840b53f883a9483fb7f2b43f3eacd857c904d1b70ecc168571b64d8f1ab82b57eea88
  Public Key compressed: 02c5389a31ce6149c28ba20d14db8540b2319e5a65000a2919fbf7a6296e7840b5

  Public Address 1: 1Bu6YxH64nfvhdDsYNEP8PftoBMqgusdPS
  Public Address 1 compressed: 18i5PtPisxbGiGGEviW7HPcnfNPmcsscwH
  Public Address 3: 38dRrGx5YbrnRWuWcJv5i2XHjYUnHE2wvv
  Public Address bc1 P2WPKH: bc1q2jxe5azr6zmhk3258av7ul6cqtu4eu4mps8f4p
  Public Address bc1 P2WSH: bc1qdveuf0egtfdnd2fnsp0lzfukn2e58czf8323ky6xt8ydew4ecfcqv3ettx
  ```



  ```python
  from bitcoinaddress import Wallet

  wallet = Wallet(testnet=True)
  print(wallet)
  ```



  ```
  Private Key HEX: 064f8f0bebfa2f65db003b56bc911535614f2764799bc89091398c1aed82e884
  Private Key WIF: 91dhN38UTmqGtd3zG1GnDdnyivAP5LnWJQyyj7V7pqthirHAj4X
  Private Key WIF compressed: cMny9rPzDAt58r8BjECeamPwN1eQSAKrKrrVNsd78AoCjcWxuVym

  Public Key: 04f7a01e30388dea9673db8cdb48b985441db785382efbcecc05abac079a6304818a907f886b0d0518e345a0288a6f1e09072f2b11d4ccb75bc67ec6c71dfef800
  Public Key compressed: 02f7a01e30388dea9673db8cdb48b985441db785382efbcecc05abac079a630481

  Public Address 1: mwdHSyBBHMbcy8rogvzssvDrGyffRo3amQ
  Public Address 1 compressed: n4VzeGfAyZGR7xCXiKmABvnKXojTFJrmKH
  Public Address 3: 2MtJ3jPSD2AYgbF25fq9cm1aUCPhSmWUMcJ
  Public Address bc1 P2WPKH: tb1qlsw8qqe2aa2avzn9t9nsfjy8kwwgarwcfvfqlh
  Public Address bc1 P2WSH: tb1qp53qkcsth8ffuvr00cnlg5hde03aszzeq7y0layklhd4nwkxzejs99tlh3
  ```



  ```python
  from bitcoinaddress import Wallet

  wallet = Wallet('5HqrbgkWPqBy6dvCE7FoUiMuiCfFPRdtRsyi6NuCM2np8qBZxq5')
  print(wallet)
  ```



  ```
  Private Key HEX: 03902e4f09664bc177fe4e090dcd9906b432b50f15fb6151984475c1c75c35b6
  Private Key WIF: 5HqrbgkWPqBy6dvCE7FoUiMuiCfFPRdtRsyi6NuCM2np8qBZxq5
  Private Key WIF compressed: KwLdv6T2jmhQbswnYrcL9KZHerTpVyjozp1JNjfP5QuD3GchCwCc

  Public Key: 04c5389a31ce6149c28ba20d14db8540b2319e5a65000a2919fbf7a6296e7840b53f883a9483fb7f2b43f3eacd857c904d1b70ecc168571b64d8f1ab82b57eea88
  Public Key compressed: 02c5389a31ce6149c28ba20d14db8540b2319e5a65000a2919fbf7a6296e7840b5

  Public Address 1: 1Bu6YxH64nfvhdDsYNEP8PftoBMqgusdPS
  Public Address 1 compressed: 18i5PtPisxbGiGGEviW7HPcnfNPmcsscwH
  Public Address 3: 38dRrGx5YbrnRWuWcJv5i2XHjYUnHE2wvv
  Public Address bc1 P2WPKH: bc1q2jxe5azr6zmhk3258av7ul6cqtu4eu4mps8f4p
  Public Address bc1 P2WSH: bc1qdveuf0egtfdnd2fnsp0lzfukn2e58czf8323ky6xt8ydew4ecfcqv3ettx
  ```



  ```python
  from bitcoinaddress import Wallet

  wallet = Wallet()
  print(wallet.key.__dict__)
  print(wallet.key.__dict__['mainnet'].__dict__)
  print(wallet.key.__dict__['testnet'].__dict__)
  print(wallet.address.__dict__)
  print(wallet.address.__dict__['mainnet'].__dict__)
  print(wallet.address.__dict__['testnet'].__dict__)
  ```



  This software is distributed under the terms of the MIT License. See the file 'LICENSE' in the root directory of the present
  distribution, or http://opensource.org/licenses/MIT.

  Bech32 address scripts source from https://github.com/sipa/bech32/tree/master/ref/python


pkgId: 423e0f9af9d47b7b99d1124ba6d65130ad116ed477a018bcace6976e46b97f74
name: python-bitcoinlib
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Bitcoin cryptocurrency Library
url: http://github.com/1200wd/bitcoinlib
rpm_license: GNU3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoinlib-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Bitcoin cryptocurrency Library writen in Python.
  Allows you to create a fully functional Bitcoin wallet with a single line of code.
  Use this library to create and manage transactions, addresses/keys, wallets, mnemonic password phrases
  and blocks with simple and straightforward Python code.
  You can use this library at a high level and create and manage wallets from the command line or at a low level
  and create your own custom made transactions, scripts, keys or wallets.
  The BitcoinLib connects to various service providers automatically to update wallets, transaction and
  blockchain information. You can also connect to a local
  `Bitcoin <https://bitcoinlib.readthedocs.io/en/latest/source/_static/manuals.setup-bitcoind-connection.html>`_ or
  `Bcoin node <https://bitcoinlib.readthedocs.io/en/latest/source/_static/manuals.setup-bcoin.html>`_.


pkgId: 5e7724708905ed4802b9facd6f1419d8311ccdbac6f0d5d5b52c50bbd440046a
name: python-bitcoinshamir
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A python implementation of the Shamir Secret Sharing scheme for BIP39 mnemonic phrases.
url: https://github.com/TylerPantuso/bitcoin-shamir
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoinshamir-1.0.1-1.src.rpm
checksum_type: sha256
description:
  A pure python implementation of the Shamir Secret Sharing scheme for use with BIP-39 mnemonic codes. Split a 24-word mnemonic phrase into several shares, and set a minimum threshold to recover your original phrase.


  `pip install bitcoinshamir`


  ```
  >>> from bitcoinshamir import *
  >>>
  >>> # Generate a random mnemonic phrase.
  >>> mnemonic = Mnemonic.generate_random()
  >>> mnemonic_phrase = get_phrase(mnemonic, Language.English)
  >>>
  >>> # Create a 3 of 5 sharing scheme, for which any 3 shares can recover the
  >>> # original mnemonic phrase.
  >>> shares = create_shares(3, 5, mnemonic)
  >>>
  >>> # Write down each share phrase and pass out to participants.
  >>> phrase_1 = get_phrase(shares[0], Language.English)
  >>> phrase_2 = get_phrase(shares[1], Language.English)
  >>> phrase_3 = get_phrase(shares[2], Language.English)
  >>> phrase_4 = get_phrase(shares[3], Language.English)
  >>> phrase_5 = get_phrase(shares[4], Language.English)
  >>>
  >>> # The original mnemonic phrase can be recovered with any three of the share
  >>> # phrases.
  >>> recovery_share_1 = Share.from_share_phrase(phrase_4, Language.English)
  >>> recovery_share_2 = Share.from_share_phrase(phrase_2, Language.English)
  >>> recovery_share_3 = Share.from_share_phrase(phrase_5, Language.English)
  >>> recovery_shares = [recovery_share_1, recovery_share_2, recovery_share_3]
  >>>
  >>> recovered_mnemonic = recover_mnemonic(recovery_shares)
  >>> recovered_phrase = get_phrase(recovered_mnemonic, Language.English)
  >>>
  >>> # You can also use recovery shares to generate new shares.
  >>> recovery_points = [share.point for share in recovery_shares]
  >>> X = 7
  >>> Y = Lagrange.interpolate(recovery_points, PRIME_MODULUS, X)
  >>> point = Point(X, Y)
  >>> threshold = recovery_shares[0].threshold
  >>> seed_checksum = recovery_shares[0].seed_checksum
  >>>
  >>> share_6 = Share(point, threshold, seed_checksum)
  >>>
  >>> # You can change the language of your share phrase or mnemonic phrase.
  >>> mnemonic = Mnemonic()
  >>> english_phrase = ["team", "lend", "rice"] # Set this to your actual phrase
  >>>
  >>> for i, word in enumerate(english_phrase):
  >>> mnemonic.set_word(i, word, Language.English)
  >>>
  >>> spanish_phrase = get_phrase(mnemonic, Language.Spanish)
  >>> italian_phrase = get_phrase(mnemonic, Language.Italian)
  >>> korean_phrase = get_phrase(mnemonic, Language.Korean)
  ```

  - You must have the minimum threshold shares to recover your original phrase.
  - Even 1 less share will not reveal a single word from the original phrase.
  - Using more shares than the threshold will still recover the original phrase.
  - Share phrases use the same BIP-39 word lists as mnemonic phrases do.
  - Each share has a checksum, which will raise an error for any miskeyed words.
  - Each share uses the original mnemonic checksum as a group ID.
  - Shares do not need to be in the same language. They are not stored as text.

  Each share represents an (X, Y) coordinate on a graph. It is 37 bytes, in order of the following:
  - 32 bytes - The Y-value of the share
  - 1 byte - The original mnemonic's checksum
  - 5 bits - The version, xor the share checksum
  - 4 bits - The threshold, xor the share checksum
  - 7 bits - The X-value, xor the share checksum
  - 2 bytes - The share checksum

  The version, threshold, and X-value are all concatenated and applied the xor of the share checksum at the same time. The share checksum is the first 2 bytes of the sha256 hash of the first 35 bytes.


pkgId: 60d86bfaa73a28adc681e0cebf4399154e75ea354b0214611e39d5e76ca727dc
name: python-bitcoinwatcher
arch: src
version: 2.5
epoch: 0
release: 1
url: https://github.com/twosatsmaxi/watcher
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitcoinwatcher-2.5-1.src.rpm
checksum_type: sha256
summary:
  bitcoinwatcher is a Python library that implements a ZMQ subscriber and provides abstractions to build custom address watchers. This library is designed to make it easy for developers to monitor Bitcoin addresses and react to changes in their state.

description:
  bitcoinwatcher is a Python library that implements a ZMQ subscriber and provides abstractions to build custom address watchers. This library is designed to make it easy for developers to monitor Bitcoin addresses and react to changes in their state.





  * Python 3.x
  * pip
  * pyzmq



  * Install the library from PyPI using `pip install bitcoinwatcher`



  * Import the library in your Python script using `from bitcoinwatcher import BitcoinWatcher`
  * Create an instance of the BitcoinWatcher and use its methods to monitor Bitcoin addresses.

  ```bash
  python your_script.py

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


pkgId: d6581a51d574e154ba51aa0d6e45a78a065a06b48c40061657c040060f0dfd28
name: python-bitdotio
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: bit.io Python SDK and CLI
url: https://github.com/bitdotioinc/python-bitdotio
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitdotio-2.2.1-1.src.rpm
checksum_type: sha256
description:
  In order to support different environments, we have a few ways to install the bitdotio
  package with or without the `psycopg2` dependency.

  1. If you already have `psycopg2` installed, you can install the default bitdotio package:
  ```
  pip install bitdotio
  ```

  2. If you already have Postgres installed, you can install with the psycopg2 dependency:
  ```
  pip install 'bitdotio[psycopg2]'
  ```

  3. If you do not have or cannot install Postgres, you can install with the psycopg2-binary dependency:
  ```
  pip install 'bitdotio[psycopg2-binary]'
  ```



  `python-bitdotio` uses [semantic versioning](https://semver.org/).





  The `bitdotio` module consists of a `bitdotio` SDK object which provides helpful
  utilities for creating and managing pre-configured connections to bit.io databases
  via `psycopg2`, as well as easy methods for accessing the functionality exposed by the
  [bit.io developer API](https://docs.bit.io/reference)

  Once you have `bitdotio` installed all you need is your API key to start working with bit.io.

  You can get your API key by logging into bit.io and opening [the "Connect" tab](https://docs.bit.io/docs/your-connection-credentials) on a database page.



  See API reference at the bottom of this document for a full list of methods provided by
  the SDK.

  ```python
  import os
  import time

  from bitdotio import bitdotio



  BITIO_KEY = os.environ.get("BITIO_KEY")


  b = bitdotio(BITIO_KEY)


  db_metadata = b.create_database("my-db", is_private=False)
  db_name = db_metadata["name"]


  with b.pooled_cursor(db_name) as cur:
      cur.execute("CREATE TABLE person (name text, age integer);")
      people = [("Alice", 45), ("Bob", 84), ("Catherine", 19), ("Davis", 22), ("Emily", 34)]
      for name, age in people:
          cur.execute("INSERT INTO person (name, age) VALUES (%s, %s)", (name, age))


  print(b.query(db_name, "SELECT * FROM person", data_format="objects"))


  with open("city.csv", "rb") as f:
      job_status = b.create_import_job("my-username/my-db", "city", file=f)
      
      while True:
          job_status = b.get_import_job(job_status["id"])
          if job_status["state"] == "DONE":
              break
          if job_status["state"] == "FAILED":
              
              
              error_id = job_status["error_id"]
              error_type = job_status["error_type"]
              error_details = job_status["error_details"]
              raise Exception(
                  f"Import failed. error_id={error_id} error_type={error_type}, error_details={error_details}"
              )

          
          time.sleep(0.2)
  ```





  The `bitdotio` SDK object provides the methods `pooled_connection`, `pooled_cursor`, and
  `get_connection` for connecting directly to your database (see below for discusson on
  when to use each of these). The connections/cursors returned by these methods are
  `psycopg2` connections and cursors, which are fully compatible with the
  [Python DB-API](https://peps.python.org/pep-0249/). Full documentation on `psycopg2` can
  be found [here](https://www.psycopg.org/docs/usage.html.).

  It is preferable to use direct connections in the majority of cases, since they have
  superior performance and enable more features compared to the `query` method. In
  particular we strongly recommend using direct connections in programs that are
  long-running, require transaction management, or transfer large quantities of data.



  The `query` runs queries via the bit.io HTTP API, and therefore will have worse
  performance and feature support than direct connections. Importantly, each query run
  via the `query` method is run in a single transaction. The `query` method is recommended
  in situations where installing a database driver is undesirable or impossible, when
  queries are being run very infrequently, or in very short-lived contexts such as one-off
  scripts or serverless backends.



  The recommended way to obtain a direct connection to a bit.io database is via a
  connection pool. In order to support scaling to zero, bit.io automatically closes idle
  connections after a period of time, and puts databases into a dormant state when there
  are no live connections. If you are designing a long-running application, you should
  make sure that your database access pattern is resilient to connection closures and
  database shutdowns. The best way to do this is via a connection pool. Acquiring
  connections from a connection pool allows connection re-use, and handles reconnects in
  the event that a connection is dropped. The `bitdotio` SDK object internally manages a
  thread-safe connection pool per-database that the caller connects to, and provides two
  helpful context mangers for acquiring connections from a pool:
  - `pooled_connection`: A context manager providing a `psycopg2` connection to the
    given database acquired from a connection pool. When exiting the context created by
    this context manager, the connection is returned to the pool if still open, or
    discarded if closed. It is recommended to use this method when executing multiple
    transacions, or in situations where explicit transaction management is required.
  - `pooled_cursor`: A context manager providing a `psycopg2` cursor created from a
    connection acquired from a connection pool. When exiting the context created by this
    context manager, the cursor's tansaction will be committed, and its connection will be
    returned to the connection pool. It is recommended to use this method in situations
    where a single transaction is required without any complex handling logic. For
    example, performing a sequence of `SELECT` queries, or performing a single insertion
    or update.

  There may be situations in which a self-managed, unpooled connection is needed. For
  example, if the client needs to persist state onto the connection's database session using
  the `SET` command. For such situations, the SDK object provides the `get_connection`
  method.

  For more information on all of the above, refer to the `psycopg2` documentation on
  [connections](https://www.psycopg.org/docs/connection.html),
  [cursors](https://www.psycopg.org/docs/cursor.html),
  and [pools](https://www.psycopg.org/docs/pool.html).



  The `bitdotio` SDK object provides helper methods to facilitate importing and exporting
  data from your bit.io database.

  To import data into a table on your bit.io database from a file locally or on the web
  you can use the `create_import_job` method. To export data from a query or a table in
  your bit.io database you can use the `create_export_job` method.

  These methods have somewhat symmetrical workflows in that they both kick off jobs on
  the bit.io backend which execute asynchronously, and have companion methods
  (`get_import_job`, and `get_export_job`) to check on the status of a running job.

  At a high level, the procedure for doing a data import looks like:
  1. Call `create_import_job` and get back the job status
  2. Use the job status info to poll `get_import_job` until the job status is reported
     as `DONE` or `FAILED`
  3. If `DONE`, the data has been successfully imported and your table is ready to query
  4. If `FAILED`, the job status object will contain metadata describing what went wrong.

  Similarly, a data export looks like:
  1. Call `create_export_job` and get back the job status
  2. Use the job status info to poll `get_export_job` until the job status is reported
     as `DONE` or `FAILED`
  3. If `DONE`, the exported data will be available to download at the `download_url`
     included in the job status info.
  4. If `FAILED`, the job status object will contain metadata describing what went wrong.



  The `bitdotio` SDK object is not safe to share between multiple processes. If you are
  programming in a multiprocess environment, ensure that a `bitdotio` SDK object is
  created per-process, not pre-fork.



  Installing the `bitdotio` module also installs the command line tool `bit` which lets
  you interact with bit.io from scripts or the command line. This is installed next to
  your python binary.

  You'll want to grab your API key from your bit.io account - to get the key, log into to
  bit.io, go to any database, and retrieve it from the "Connect" tab.

  ```
  Usage: bit [OPTIONS] COMMAND [ARGS]...

  Options:
    -k, --key TEXT  Your bit.io API key, available when you click the connect
                    button in bit.io
    --help          Show this message and exit.

  Commands:
    db
    query
  ```

  All of the commands return JSON.

  You can supply your API key either via the `-k/--key` argument, or by setting the it to
  the `BITIO_KEY` environment variable. The latter option keeps the key from showing up
  in, eg, a `ps` command, and allows secret injection for systems like Kubernetes.





  ```sh
  BITIO_KEY=<your key> bit db list
  ```

  This is the same as:

  ```sh
  bit -k <your-key> db list
  ```


  ```sh
  bit -k <your-key> query -d "username/dbname" -q "SELECT * FROM my_table"
  ```





  Returns an instance of the bit.io SDK object.

  _Args_:
  - `access_token (str)`: Your bit.io API key

  _Kwargs_:
  - `min_conn (int)`: The minimum number of live connections per database connection pool.
  - `max_conn (int)`: The maximum number of live connections per database connection pool.

  _Returns_:

  A bit.io SDK instance

  <hr>



  Creates a context manager which provides a connection from the connection pool for the
  given database name. When the context manager is exited, the connection's transaction
  will be committed, and the connection will be returned to the connection pool.

  _Args_:
  - `db_name (str)`: The name of the database to connect to.

  _Returns_:

  Context manager yielding a `psycopg2.connection`.

  <hr>



  Creates a context manager which provides a cursor from the connection pool for the
  given database name. When the context manager is exited, the cursor's transaction will
  be committed, and its connection will be returned to the connection pool.

  _Args_:
  - `db_name (str)`: The name of the database to connect to.

  _Returns_:

  Context manager yielding a `psycopg2.connection`.

  <hr>



  Returns an unmanaged, unpooled connection to the given database.

  _Args_:
  - `db_name (str)`: The name of the database to connect to.

  _Returns_:

  A `psycopg2.connection` object configured for the given database.

  <hr>



  Execute a query via the bit.io HTTP API

  _Args_:
  - `db_name (str)`: Name of the database to execute a query against.
  - `query_str (str)`: Query to execute.

  _Kwargs_:
  - `data_format (Optional[str])`:

  _Returns_:

  Dictionary describing query results.

  <hr>



  List metadata pertaining to databases the requester is an owner or collaborator of.

  _Returns_:

  List of dictionaries describing database metadata.

  <hr>



  _Args_:
  - `name (str)`: Name of the database being created (excluding the owner's username)

  _Kwargs_:
  - `is_private (bool)`: Whether or not the database is set to private. Databases default
    to private.
  - `storage_limit_bytes (Optional[int])`: Maximum storage for the database in bytes.
    Limits and defaults are enforced based on billing plan regardless of what is set here.

  _Returns_:

  Dict containing metadata about the newly created database.

  <hr>



  Get metadata about a single database.

  _Args_:
  - `db_name (str)`: Name of the database to fetch metadata for.

  _Returns_:

  Dict containing metadata about the given database.

  <hr>



  Update metadata parameters for a given database.

  _Args_:
  - `db_name (str)`: Name of the database to update.

  _Kwargs_:
  - `name (Optional[str])`: New name for the database (excluding the owner's username).
  - `is_private (Optional[str])`: Whether or not the database is set to private.
  - `storage_limit_bytes (Optional[int])`: Maximum storage for the database in bytes.
    Limits and defaults are enforced based on billing plan regardless of what is set here.

  _Returns_:

  Up to date metadata about the updated database.

  <hr>



  Delete a database. After deletion the database's name will be unusable for up to 30
  days. If you need to reuse it sooner, please contact bit.io support.

  _Args_:
  - `db_name (str)`: Name of the database to delete

  _Returns_:

  None.

  <hr>



  Start a data import job from a file or a URL. Supported filetypes CSV, JSON, XLS/XLSX,
  and SQLite.

  _Args_:
  - `db_name (str)`: Name of the database to import data into
  - `table_name (str)`: Name of the table to import data into
  - `schema_name (Optional[str])`: Name schema in which the target table resides. Not
    required if the table is in the `public` schema.
  - `infer_header (Optional[str])`: If relevant to the given filetype, indicates how the
    first row of the data should be interpreted. Should be one of `auto`, `first_row`, or
    `no_header`. If `auto`, we will attempt to determine automatically if there is a
    header or not. If `first_row`, the first row of the data will be used as the header.
    If `no_header`, the first row of the data will be interpreted as data.
  - `file (Optional[file-like])`: A file-like object to upload. If this is passed,
    `file_url` must not be passsed.
  - `file_url (Optional[str])`: A URL to import a file from. The URL should point to a
    supported filetype on the web. If this is passed, `file` must not be passed.

  _Returns_:

  A dict describing the status of the import job. The dict contains the fields `id`, and
  `status_url`. The value of `id` can be passed to `get_import_job` to get the updated
  status of the import job. `status_url` can also be requested directly to get the same.
  Also included is the `state` field, which indicates the current status of the job.
  Possible values of `state` are `RECEIVED`, `PROCESSING`, `DONE`, and `FAILED`.

  <hr>



  Retrieves the status and other metadata about a given data import job. See the docs for
  `create_import_job` for more details on import job statuses and metadata fields.

  _Args_:
  - `import_id (str)`: The ID of the import job to retrieve info for.

  _Returns_:

  A dict describing the status and metadata of an import job.

  <hr>



  Start a data export job from a query or a full table. Supported export filetypes are
  CSV, JSON, XLS, and Parquet.

  _Args_:
  - `db_name (str)`: Name of the database to export data from
  - `query_string (Optional[str])`: A query to export results for. Providing this option
     will run the query on your database. If this is passed, `table_name` and `schema_name`
     must not be passed.
  - `table_name (Optional[str])`: Name of the table to export data from. If this is
    passed, `query_string` must not be passed.
  - `schema_name (Optional[str])`: Name schema in which the exported table resides. Not
    required if the table is in the `public` schema.
  - `file_name (Optional[str])`: Name of the exported file.
  - `export_format (str)`: File format to export data to. Accepted values are `csv`,
    `json`, `xls`, and `parquet`. Defaults to `csv`.

  _Returns_:

  A dict describing the status of the export job. The dict contains the fields `id`, and
  `status_url`. The value of `id` can be passed to `get_export_job` to get the updated
  status of the export job. `status_url` can also be requested directly to get the same.
  Also included is the `state` field, which indicates the current status of the job.
  Possible values of `state` are `RECEIVED`, `PROCESSING`, `DONE`, and `FAILED`. When
  the status of the job reaches `DONE`, the field `download_url` will have a non-null
  value, and the exported file can be downloaded from it.

  <hr>



  Retrieves the status and other metadata about a given data export job. See the docs for
  `create_export_job` for more details on export job statuses and metadata fields.

  _Args_:
  - `export_id (str)`: The ID of the export job to retrieve info for.

  _Returns_:

  A dict describing the status and metadata of an export job.

  <hr>



  List metadata pertaining to service accounts the requester has created.

  _Returns_:

  List of dictionaries describing service account metadata.

  <hr>



  Get metadata about a single service account

  _Args_:

  - `service_account_id (str)`: ID of the service account

  _Returns_:

  Dictionary describing service account metadata.

  <hr>



  Create a new API key/database password for a given service account

  _Args_:

  - `service_account_id (str)`: ID of the service account

  _Returns_:

  Dictionary containing newly created credentials

  <hr>



  Revoke all API keys/database passwords for the given service account

  _Args_:

  - `service_account_id (str)`: ID of the service account

  _Returns_: None

  <hr>



  Create a new API key/database password with the same permissions as the requester

  _Returns_:

  Dictionary containing newly created credentials

  <hr>



  Revoke API keys/database passwords. If `api_key` is given, only that API key will
  be revoked. Otherwise, all API keys for the requester will be revoked.

  _Kwargs_:
  - `api_key (Optional[str])`: API key to revoke

  _Returns_: None

  <hr>


pkgId: 09598c9c91183b13c41a15da4bf9091d0be5d62a69ccca6ddc202025cc19f72d
name: python-bitdust
arch: src
version: 0.1.15.249
epoch: 0
release: 1
summary: p2p secure distributed storage and communication engine
url: https://bitdust.io
rpm_license: Copyright (C) 2008 Veselin Penev, https://bitdust.io
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitdust-0.1.15.249-1.src.rpm
checksum_type: sha256
description:
  BitDust is a peer to peer online backup utility.
  This is a distributed network for backup data storage. Each participant of the network provides a portion of his hard drive for other users. In exchange, he is able to store his data on other peers.
  The redundancy in backup makes it so if someone loses your data, you can rebuild what was lost and give it to someone else to hold. And all of this happens without you having to do a thing - the software keeps your data in safe.
  All your data is encrypted before it leaves your computer with a private key your computer generates. No one else can read your data, even BitDust Team! Recover data is only one way - download the necessary pieces from computers of other peers and decrypt them with your private key.
  BitDust is written in Python using pure Twisted framework and published under GNU AGPLv3.
  https://bitdust.io


pkgId: a151827354440c4038cc532946b8531e33aef447fc9e35b5ceb1bb27555aafc8
name: python-biteen-utilities
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Tools for working with single-molecule localization data.
url: https://pypi.org/project/biteen-utilities/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biteen-utilities-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A repository for common coding tasks in the Biteen Lab.


  Reading, writing, and converting between different file types.
  * convert .nd2 to .tif
  * convert .nd2 to .npy
  * extract ROIs from cellpose .npy into 2d numpy array
  * convert cellpose .npy to .mat (SMALL-LABS format)
  * convert SMALL-LABS output (*_fits.mat, *_guesses.mat) to pandas DataFrame
  * convert SMALL-LABS output (*_fits.mat, *_guesses.mat) to .csv
  * convert pandas DataFrame to SMALL-LABS format .mat
  * convert SMALL-LABS output to Spot-On format
  * convert pandas DataFrame to Spot-On format


  Working with tabular data stored in pandas DataFrames.
  * calculate individual step data from localizations
  * filter localization data by number of localizations in each track
  * calculate median step size for each track


  Plotting single-molecule data.
  * Plot localizations overlayed on image data, e.g. phase contrast
  * Plot trajectories overlayed on image data, e.g. phase contrast


  * dpsp related format conversions
  * drift correction with RCC
  * using napari
  * MSD
  * using NOBIAS output
  * heatmaps
  * rotation to align with cell axes


pkgId: 5b66ba8c65f53abe13650d729bab70bc5d90ab3c57e7a174e8d64ed5fc92bee4
name: python-bitflags
arch: src
version: 1.1.3
epoch: 0
release: 1
url: https://github.com/justengel/bitflags
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitflags-1.1.3-1.src.rpm
checksum_type: sha256
summary:
  Bit flags implementation using a C Union. This library removes the need to use ctypes and helps you quickly access what bits are toggled.


pkgId: 6899e299980efc029129b92393b1f3884773b632958396e26d9202220412546d
name: python-bitly-api-py3
arch: src
version: 0.3
epoch: 0
release: 1
summary: An API for bit.ly forked for Python 3 support
url: https://github.com/develtech/bitly-api-python
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitly-api-py3-0.3-1.src.rpm
checksum_type: sha256
description:
      pip install bitly_api

  Your username is the lowercase name shown when you login to bitly, your access token can be fetched using the following ( http://dev.bitly.com/authentication.html ):
      curl -u "username:password" -X POST "https://api-ssl.bitly.com/oauth/access_token"
  To run the tests either export the environment variable or set it up inline before calling `nosetests`:
      bitly-api-python $ BITLY_ACCESS_TOKEN=<accesstoken> nosetests

  http://dev.bitly.com/


pkgId: ac276f5cb5aceff9cf2a175de069566eff8bf4c1d20b261b9065234f4783c888
name: python-bitmap
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: .
url: https://github.com/wanji/bitmap
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitmap-0.0.7-1.src.rpm
checksum_type: sha256
description:
  This package provides a `BitMap` class which is an array of bits stored in compact format.

  `bitmap` can be installed from `pip`:
  ```bash
  $ sudo pip install bitmap
  ```

  - `BitMap(maxnum)`: construct a `BitMap` object with `maxnum` bits
  - `set(pos)`: set the bit at position `pos` to 1
  - `reset(pos)`: reset the bit at position `pos` to 0
  - `flip(pos)`: flip the bit at position `pos`
  - `count()`: return the number of 1s
  - `size()`: return the size of the `BitMap`
  - `test(pos)`: check if bit at position `pos` has been set to 1
  - `any()`: check if any bit in the `BitMap` has been set to 1
  - `none()`: check if none of the bits in the `BitMap` has been set to 1
  - `all()`: check if all bits in the `BitMap` has been set to 1
  - `nonzero()`: return indexes of all non-zero bits
  - `tostring()`: convert a `BitMap` object to `0` and `1` string
  - `fromstring(bitstring)`: create a `BitMap` object from `0` and `1` string

  ```python
  from bitmap import BitMap
  bm = BitMap(32)
  print bm.tostring()
  bm.set(1)
  print bm.tostring()
  bm = BitMap.fromstring("00011101")
  print bm.tostring()
  bm.flip(1)
  print bm.tostring()
  ```


pkgId: 4c14a4608981bccf6d551900c0363e612f28b31f0624518b631bb924ce903307
name: python-bitmapist
arch: src
version: 3.114
epoch: 0
release: 1
summary: Implements a powerful analytics library using Redis bitmaps.
url: https://github.com/Doist/bitmapist
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitmapist-3.114-1.src.rpm
checksum_type: sha256
description:
  ![bitmapist](https://raw.githubusercontent.com/Doist/bitmapist/master/static/bitmapist.png "bitmapist")


  [![Build Status](https://travis-ci.org/Doist/bitmapist.svg?branch=master)](https://travis-ci.org/Doist/bitmapist)

  **NEW!** Try out our new standalone [bitmapist-server](https://github.com/Doist/bitmapist-server), which improves memory efficiency 443 times and makes your setup much cheaper to run (and more scaleable). It's fully compatiable with bitmapist that runs on Redis.



  This Python library makes it possible to implement real-time, highly scalable analytics that can answer following questions:

  * Has user 123 been online today? This week? This month?
  * Has user 123 performed action "X"?
  * How many users have been active this month? This hour?
  * How many unique users have performed action "X" this week?
  * How many % of users that were active last week are still active?
  * How many % of users that were active last month are still active this month?
  * What users performed action "X"?

  This library is very easy to use and enables you to create your own reports easily.

  Using Redis bitmaps you can store events for millions of users in a very little amount of memory (megabytes).
  You should be careful about using huge ids as this could require larger amounts of memory. Ids should be in range [0, 2^32).

  Additionally bitmapist can generate cohort graphs that can do following:
  * Cohort over user retention
  * How many % of users that were active last [days, weeks, months] are still active?
  * How many % of users that performed action X also performed action Y (and this over time)
  * And a lot of other things!

  If you want to read more about bitmaps please read following:

  * http://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps/
  * http://redis.io/commands/setbit
  * http://en.wikipedia.org/wiki/Bit_array
  * http://www.slideshare.net/crashlytics/crashlytics-on-redis-analytics





  Can be installed very easily via:

      $ pip install bitmapist




  * PHP port: https://github.com/jeremyFreeAgent/Bitter




  Setting things up:

  ```python
  from datetime import datetime, timedelta
  from bitmapist import setup_redis, delete_all_events, mark_event,\
                        MonthEvents, WeekEvents, DayEvents, HourEvents,\
                        BitOpAnd, BitOpOr

  now = datetime.utcnow()
  last_month = datetime.utcnow() - timedelta(days=30)
  ```

  Mark user 123 as active and has played a song:

  ```python
  mark_event('active', 123)
  mark_event('song:played', 123)
  ```

  Answer if user 123 has been active this month:

  ```python
  assert 123 in MonthEvents('active', now.year, now.month)
  assert 123 in MonthEvents('song:played', now.year, now.month)
  assert MonthEvents('active', now.year, now.month).has_events_marked() == True
  ```


  How many users have been active this week?:

  ```python
  print(len(WeekEvents('active', now.year, now.isocalendar()[1])))
  ```

  Iterate over all users active this week:

  ```python
  for uid in WeekEvents('active'):
      print(uid)
  ```


  If you're interested in "current events", you can omit extra `now.whatever`
  arguments. Events will be populated with current time automatically.

  For example, these two calls are equivalent:

  ```python

  MonthEvents('active') == MonthEvents('active', now.year, now.month)

  ```

  Additionally, for the sake of uniformity, you can create an event from
  any datetime object with a `from_date` static method.

  ```python

  MonthEvents('active').from_date(now) == MonthEvents('active', now.year, now.month)

  ```

  Get the list of these users (user ids):

  ```python
  print(list(WeekEvents('active', now.year, now.isocalendar()[1])))
  ```

  There are special methods `prev` and `next` returning "sibling" events and
  allowing you to walk through events in time without any sophisticated
  iterators. A `delta` method allows you to "jump" forward or backward for
  more than one step. Uniform API allows you to use all types of base events
  (from hour to year) with the same code.

  ```python

  current_month = MonthEvents()
  prev_month = current_month.prev()
  next_month = current_month.next()
  year_ago = current_month.delta(-12)

  ```

  Every event object has `period_start` and `period_end` methods to find a
  time span of the event. This can be useful for caching values when the caching
  of "events in future" is not desirable:

  ```python

  ev = MonthEvent('active', dt)
  if ev.period_end() < now:
      cache.set('active_users_<...>', len(ev))

  ```


  As something new tracking hourly is disabled (to save memory!) To enable it as default do::

  ```python
  import bitmapist
  bitmapist.TRACK_HOURLY = True
  ```

  Additionally you can supply an extra argument to `mark_event` to bypass the default value::

  ```python
  mark_event('active', 123, track_hourly=False)
  ```




  Sometimes the date of the event makes little or no sense, for example,
  to filter out your premium accounts, or in A/B testing. There is a
  `UniqueEvents` model for this purpose. The model creates only one
  Redis key and doesn't depend on the date.

  You can combine unique events with other types of events.

  A/B testing example:

  ```python

  active_today = DailyEvents('active')
  a = UniqueEvents('signup_form:classic')
  b = UniqueEvents('signup_form:new')

  print("Active users, signed up with classic form", len(active & a))
  print("Active users, signed up with new form", len(active & b))
  ```

  Generic filter example

  ```python

  def premium_up(uid):
      
      ...
      mark_unique('premium', uid)


  def premium_down(uid):
      
      ...
      unmark_unique('premium', uid)

  active_today = DailyEvents('active')
  premium = UniqueEvents('premium')



  for uid in premium & active_today:
      add_extra_karma(uid)
  ```

  To get the best of two worlds you can mark unique event and regular
  bitmapist events at the same time.


  ```python
  def premium_up(uid):
      
      ...
      mark_event('premium', uid, track_unique=True)

  ```




  How many users that have been active last month are still active this month?

  ```python
  active_2_months = BitOpAnd(
      MonthEvents('active', last_month.year, last_month.month),
      MonthEvents('active', now.year, now.month)
  )
  print(len(active_2_months))


  assert 123 in active_2_months
  ```

  Alternatively, you can use standard Python syntax for bitwise operations.


  ```python
  last_month_event = MonthEvents('active', last_month.year, last_month.month)
  this_month_event = MonthEvents('active', now.year, now.month)
  active_two_months = last_month_event & this_month_event
  ```
  Operators `&`, `|`, `^` and `~` supported.

  Work with nested bit operations (imagine what you can do with this ;-))!

  ```python
  active_2_months = BitOpAnd(
      BitOpAnd(
          MonthEvents('active', last_month.year, last_month.month),
          MonthEvents('active', now.year, now.month)
      ),
      MonthEvents('active', now.year, now.month)
  )
  print(len(active_2_months))
  assert 123 in active_2_months


  active_2_months.delete()
  ```




  If you want to permanently remove marked events for any time period you can use the `delete()` method:
  ```python
  last_month_event = MonthEvents('active', last_month.year, last_month.month)
  last_month_event.delete()
  ```

  If you want to remove all bitmapist events use:
  ```python
  bitmapist.delete_all_events()
  ```

  When using Bit Operations (ie `BitOpAnd`) you can (and probably should) delete the results unless you want them cached. There are different ways to go about this:
  ```python
  active_2_months = BitOpAnd(
      MonthEvents('active', last_month.year, last_month.month),
      MonthEvents('active', now.year, now.month)
  )

  active_2_months.delete()


  bitmapist.delete_runtime_bitop_keys()


  bitmapist.delete_temporary_bitop_keys()
  ```




  With bitmapist cohort you can get a form and a table rendering of the data you keep in bitmapist. If this sounds confusing [please look at Mixpanel](https://mixpanel.com/retention/).

  Here's a simple example of how to generate a form and a rendering of the data you have inside bitmapist:
  ```python
  from bitmapist import cohort

  html_form = cohort.render_html_form(
      action_url='/_Cohort',
      selections1=[ ('Are Active', 'user:active'), ],
      selections2=[ ('Task completed', 'task:complete'), ]
  )
  print(html_form)

  dates_data = cohort.get_dates_data(select1='user:active',
                                     select2='task:complete',
                                     time_group='days')

  html_data = cohort.render_html_data(dates_data,
                                      time_group='days')

  print(html_data)



  ```

  This will render something similar to this:

  ![bitmapist cohort screenshot](https://raw.githubusercontent.com/Doist/bitmapist/master/static/cohort_screenshot.png "bitmapist cohort screenshot")




  Please see our guide [here](./CONTRIBUTING.md)



  We use Poetry for dependency management & packaging.  Please see [here for setup instructions](https://python-poetry.org/docs/#installation).

  Once you have Poetry installed, you can run the following to install the dependencies in a virtual environment:

  ```bash
  poetry install
  ```



  To run our tests will need to ensure a local redis server is installed.

  We use pytest to run unittests which you can run in a poetry shell with

  ```bash
  poetry run pytest
  ```



  - Bump version in `pyproject.toml`
  - Update the CHANGELOG
  - Commit the changes with a commit message "Version X.X.X"
  - Tag the current commit with `vX.X.X`
  - Create a new release on GitHub named `vX.X.X`
  - GitHub Actions will publish the new version to PIP for you



  Copyright: 2012 by Doist Ltd.

  License: BSD


pkgId: 1ad51cd2a0d401ad12fa6d4b1f0b85c369861ad771980e0e43c90e06388d2ce1
name: python-bitmat-tl
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: An efficent implementation for the paper: "The Era of 1-bit LLMs"
url: https://github.com/astramind-ai/BitMat/tree/main
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitmat-tl-0.3.7-1.src.rpm
checksum_type: sha256
description:
  | Model  | Supported |
  | ------------- | ------------- |
  | Mistral  |  ✅ |
  | LLama  |  ✅ |
  | Gemma  |  ✅ |



  BitMat is a Python package designed to optimize matrix multiplication operations by utilizing custom kernels written in Triton. Our package leverages the principles outlined in the "1bit-LLM Era" paper, specifically utilizing packed int8 data to enhance computational efficiency and performance in deep learning and numerical computing tasks.


  Custom Triton Kernels: Utilize highly optimized kernels for matrix multiplication, tailored for performance and efficiency.

  Packed int8 Operations: During inference the model uses packed int8 data to reduce memory usage and improve computational efficiency.

  Ease of Integration: BitMat is designed to be easily integrated into existing PyTorch/transformers workflows, providing a seamless user experience.

  ```bash
  pip install bitmat-tl
  ```
  At the moment we only support **Linux** platforms. **Windows** installation is possible but is not tested.



  ```python
  from transformers import AutoModelForCausalLM
  from bitmat import convert_hf_model


  model= AutoModelForCausalLM.from_pretrained("some-repo/some-model")

  model = convert_hf_model(model)

  model.save_pretrained('some_local_folder')
  ```

  To utilize the converted 1.58Bit model, such as a customized version of Mistral in this exmaple, you will need to load the model from the AutoClass. Below is an example demonstrating how to load the model from a local directory:

  ```python
  from bitmat import Auto158ModelForCausalLM


  model = Auto158ModelForCausalLM.from_pretrained('path_to_your_model')
  ```
  Once loaded, the model operates in two distinct modes:

  - Evaluation Mode: By default, the model employs quantized weights, optimizing performance for inference tasks. Activate this mode using model.eval().

  - Training Mode: Switching to this mode, via model.train(), allows the model to leverage full-precision weights, which is essential for training and fine-tuning processes, ensuring accurate gradient calculations and effective model updates.


  This API is **fully compatible** with the HuggingFace's Ecosystem



  ```python
  import torch
  from bitmat import BitLinear

  layer = BitLinear(in_features=1024, out_features=512, bias=True, eps=1e-5)

  ```



  It can be observed that the performance of the custom matmul to
  handle the multiplication of ternary matrices is better for higher precision.
  This may be due to the optimized process within the GPU.


  **(left) 16-bit precision, (right) 32-bit precision**

   <img src="https://github.com/astramind-ai/BitMat/assets/121761685/5f768ce3-c947-4be6-82f0-5346f78d6645)" width="400" alt="Graph #1"> <img src="https://github.com/astramind-ai/BitMat/assets/121761685/5f768ce3-c947-4be6-82f0-5346f78d6645" width="400" alt="Graph #2">



  We welcome contributions from the community, whether it's adding new features, improving documentation, or reporting bugs. Please refer to our contribution guidelines before making a pull request.


  BitMat is open-sourced under the Apache-2.0 license.


  If you use BitMat in your research, please cite it using the following Bibtex entry:

  ```bibtex
  @article{bitmat2024,
    title={BitMat: Improving Matrix Multiplication with Custom Triton Kernels},
    author={AstraMind AI},
    journal={https://github.com/astramind-ai/BitMat},
    year={2024}
  }
  ```

  For questions, issues, or support regarding BitMat, please open an issue on our GitHub repository.


  Special thanks to the Triton community and the authors of the "1bit-LLM Era" paper for their groundbreaking work and inspiration.

  Also thanks to the developer of [BitDelta](https://github.com/FasterDecoding/BitDelta/) and [UnSloth](https://github.com/unslothai/unsloth) since part of the code is based on their work.


pkgId: 371f0f98f9a4d63441c11fa0a7ede056421d825d38558999c52aafd2a4e3a75c
name: python-bitmath
arch: src
version: 1.3.3.1
epoch: 0
release: 1
url: https://github.com/tbielawa/bitmath
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitmath-1.3.3.1-1.src.rpm
checksum_type: sha256
summary:
  Pythonic module for representing and manipulating file sizes with different prefix notations (file size unit conversion)

description:
  `bitmath <http://bitmath.readthedocs.org/en/latest/>`_ simplifies many
  facets of interacting with file sizes in various units. Originally
  focusing on file size unit conversion, functionality now includes:
  * Converting between **SI** and **NIST** prefix units (``kB`` to ``GiB``)
  * Converting between units of the same type (SI to SI, or NIST to NIST)
  * Automatic human-readable prefix selection (like in `hurry.filesize <https://pypi.python.org/pypi/hurry.filesize>`_)
  * Basic arithmetic operations (subtracting 42KiB from 50GiB)
  * Rich comparison operations (``1024 Bytes == 1KiB``)
  * bitwise operations (``<<``, ``>>``, ``&``, ``|``, ``^``)
  * Reading a device's storage capacity (Linux/OS X support only)
  * `argparse <https://docs.python.org/2/library/argparse.html>`_
    integration as a custom type
  * `progressbar <https://code.google.com/p/python-progressbar/>`_
    integration as a better file transfer speed widget
  * String parsing
  * Sorting
  In addition to the conversion and math operations, `bitmath` provides
  human readable representations of values which are suitable for use in
  interactive shells as well as larger scripts and applications. The
  format produced for these representations is customizable via the
  functionality included in stdlibs `string.format
  <https://docs.python.org/2/library/string.html>`_.
  In discussion we will refer to the NIST units primarily. I.e., instead
  of "megabyte" we will refer to "mebibyte". The former is ``10^3 =
  1,000,000`` bytes, whereas the second is ``2^20 = 1,048,576``
  bytes. When you see file sizes or transfer rates in your web browser,
  most of the time what you're really seeing are the base-2 sizes/rates.
  **Don't Forget!** The source for bitmath `is available on GitHub
  <https://github.com/tbielawa/bitmath>`_.
  And did we mention there's almost 200 unittests? `Check them out for
  yourself <https://github.com/tbielawa/bitmath/tree/master/tests>`_.


pkgId: 5b915b4cdc292a617e0bafe64693ea173eb0eaf69954c2087e6b27f8b1fe0539
name: python-bitmovin-api-sdk
arch: src
version: 1.209.0
epoch: 0
release: 1
url: https://github.com/bitmovin/bitmovin-api-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitmovin-api-sdk-1.209.0-1.src.rpm
checksum_type: sha256
summary:
  Python-Client which enables you to seamlessly integrate the Bitmovin API into your projects. Using this API client requires an active account.

description:
  Python-Client which enables you to seamlessly integrate the Bitmovin API into your projects. Using this API client requires an active account.


pkgId: 7b48f97849fb0806adadd7ece86dce8c304c596cd8249c43c8e6e7542147efd1
name: python-bitn
arch: src
version: 0.0.45
epoch: 0
release: 1
summary: a better bitslicer9k
url: https://github.com/futzu/bitn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitn-0.0.45-1.src.rpm
checksum_type: sha256
description:
  * Super fast bitslicing.
  * bitshift speed without bitwise complexity.

  * the __reverse__ bitn.BitBin
  * Encodes values to bytes


  ```python3
  pip install bitn
  ```


  ```
  NAME
      bitn

  CLASSES
      builtins.object
          BitBin
          NBin

      class BitBin(builtins.object)
       |  bitn.Bitbin takes a byte string and
       |  converts it to a integer, a very large integer
       |  if needed. A 1500 bit integer is no problem.
       |  several methods are available for slicing off bits.
       |
       |  Methods defined here:
       |
       |  __init__(self, bites)
       |
       |  as90k(self, num_bits)
       |      Returns num_bits
       |      of bits as 90k time
       |
       |  asascii(self, num_bits)
       |      Returns num_bits
       |      as bytes decoded to ascii
       |
       |  asflag(self, num_bits=1)
       |      Returns one bit as True or False
       |
       |  ashex(self, num_bits)
       |      Returns the hex value
       |      of num_bits of bits
       |
       |  asint(self, num_bits)
       |      Starting at self.idx of self.bits,
       |      slice off num_bits of bits.
       |
       |  forward(self, num_bits)
       |      Advances the start point
       |      forward by num_bits
       |
       |  negative_shift(self, num_bits)
       |      negative_shift is called instead of
       |      throwing a negative shift count error.
       |
       |  ----------------------------------------------------------------------


      class NBin(builtins.object)
       |  bitn.NBin is
       |  the reverse BitBin.
       |  Encodes data to integers
       |  and then bytes
       |
       |  Methods defined here:
       |
       |  __init__(self)
       |
       |  add_90k(self, pts, bit_len=33)
           |      Converts 90k  float timestamps
       |      to an int and appends it to nbits
       |      via self.add_int
       |
       |  add_flag(self, flg)
       |      add_flag takes a boolean
       |      value and adds it as an integer
       |      to self.nbits via self.add_int
       |
       |  add_hex(self, hex_str, bit_len)
       |      add_hex converts a
       |      hex encoded string to an int
       |      and appends it to self.nbits
       |      via self.add_int
       |
       |  add_int(self, int_bits, bit_len)
       |      left shift nbits and append new_bits
       |
       |  forward(self, num)
       |      Currently just an alias to reserve
       |
       |  nbits2bites(self)
       |      nbits2bites converts
       |      the int self.nbits to bytes as self.bites
       |      and sets self.nbits  and self.idx to 0
       |
       |  reserve(self, num)
       |      reserve sets 'num'  bits to 1
       |      and appends them to self.nbits
       |      via self.add_int
       |
       |  ----------------------------------------------------------------------


  ```


   I used to do this
  ```python3
     from struct import unpack

      sync,two_bytes,one_byte = unpack('>BHB', packet[:4])
      tei = two_bytes >> 15
      pusi = two_bytes >> 14 & 0x1
      ts_priority = two_bytes >>13 & 0x1
      pid = two_bytes & 0x1fff
      scramble = one_byte >>6
      afc = (one_byte & 48) >> 4
      count = one_byte & 15
  ```
   Now I use bitn and do this
  ```python3
      from bitn import BitBin

      header= BitBin(packet[:4])
      sync=header.asint(8)
      tei=header.asflag(1)
      pusi=header.asflag(1)
      ts_priority=header.asflag(1)
      pid=header.asint(13)
      scramble=header.asint(2)
      afc=header.asint(2)
      count=header.asint(4)
  ```


    *  Parse  a SCTE 35 splice information section from a hex encoded string

  ```python3

  >>> from bitn import BitBin


  >>> bites= bytes.fromhex('FC302F000000000000FFFFF00506FEAEF17C4C0019021743554549480000077F9F0808000000002CA56C97110000C4876A2E')

  >>> class Splice_Info_Section:

          def __init__(self,bitbin):
              self.table_id =bitbin.ashex(8)
              self.section_syntax_indicator = bitbin.asflag(1)
              self.private = bitbin.asflag(1)
              self.reserved=bitbin.asint(2)
              self.section_length = bitbin.asint(12)
              self.protocol_version = bitbin.asint(8)
              self.encrypted_packet =  bitbin.asflag(1)
              self.encryption_algorithm =bitbin.asint(6)
              self.pts_adjustment = bitbin.as90k(33)
              self.cw_index = bitbin.ashex(8)
              self.tier = bitbin.ashex(12)
              self.splice_command_length = bitbin.asint(12)
              self.splice_command_type = bitbin.asint(8)


  >>> bitbin=BitBin(bites)

  >>> sps=Splice_Info_Section(bitbin)

  >>> vars(sps)

  {'table_id': '0xfc', 'section_syntax_indicator': False, 'private': False, 'reserved': 3, 'section_length': 47,
  'protocol_version': 0, 'encrypted_packet': False, 'encryption_algorithm': 0, 'pts_adjustment': '0.000000',
  'cw_index': '0xff', 'tier': '0xfff', 'splice_command_length': 5, 'splice_command_type': 6, 'descriptor_loop_length': 25}

  >>>

  ```


pkgId: d19dc49a2d10b568b8910446f525d471c14881aff5c406a9830ace0fcf5b9a8f
name: python-bitnet
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: bitnet - Pytorch
url: https://github.com/kyegomez/bitnet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitnet-0.2.5-1.src.rpm
checksum_type: sha256
description:
  - Fully implemented Transformer as described in the diagram with MHA, and BitFeedforwards
  - Can be utilized not just for text but for images and maybe even video or audio processing
  - Complete with residuals and skip connections for gradient flow
  ```python

  import torch
  from bitnet import BitNetTransformer

  x = torch.randint(0, 20000, (1, 1024))

  bitnet = BitNetTransformer(
      num_tokens=20000,  # Number of unique tokens in the input
      dim=1024,  # Dimension of the input and output embeddings
      depth=6,  # Number of transformer layers
      heads=8,  # Number of attention heads
      ff_mult=4,  # Multiplier for the hidden dimension in the feed-forward network
  )

  logits = bitnet(x)

  print(logits)
  ```

  This Attention has been modified to use BitLinear instead of the default linear projection. It's also using Multi-Grouped Query Attention instead of regular multi-head attention for faster decoding and longer context handling.
  ```python
  import torch
  from bitnet import BitMGQA

  x = torch.randn(1, 10, 512)

  gqa = BitMGQA(512, 8, 4)

  out, _ = gqa(x, x, x, need_weights=True)

  print(out)
  ```

  - Feedforward as shown in the diagram with BitLinear and a GELU:
  - Linear -> GELU -> Linear
  - You can add dropouts, or layernorms, or other layers for a better ffn
  ```python
  import torch
  from bitnet import BitFeedForward

  x = torch.randn(10, 512)







  ff = BitFeedForward(512, 512, 4, swish=True, post_act_ln=True, dropout=0.1)

  y = ff(x)

  print(y)  # torch.Size([10, 512])
  ```

  ```python
  from bitnet import BitNetInference
  bitnet = BitNetInference()
  bitnet.load_model("../model_checkpoint.pth")  # Download model
  output_str = bitnet.generate("The dog jumped over the ", 512)
  print(output_str)
  ```

  ```python
  import torch
  from transformers import AutoModelForSequenceClassification, AutoTokenizer
  from bitnet import replace_linears_in_hf

  model_name = "bert-base-uncased"
  tokenizer = AutoTokenizer.from_pretrained(model_name)
  model = AutoModelForSequenceClassification.from_pretrained(model_name)

  replace_linears_in_hf(model)

  text = "Replace this with your text"
  inputs = tokenizer(
      text, return_tensors="pt", padding=True, truncation=True, max_length=512
  )

  model.eval()  # Set the model to evaluation mode
  with torch.no_grad():
      outputs = model(**inputs)
      predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
      print(predictions)

  predicted_class_id = predictions.argmax().item()
  print(f"Predicted class ID: {predicted_class_id}")



  ```

  ```python
  import torch
  from torch import nn
  from bitnet import replace_linears_in_pytorch_model

  model = nn.Sequential(
      nn.Linear(10, 20),
      nn.ReLU(),
      nn.Linear(20, 30),
  )
  print("Before replacement:")
  print(model)

  replace_linears_in_pytorch_model(model)
  print("After replacement:")
  print(model)


  input = torch.randn(1, 10)
  output = model(input)
  ```

  `python setup.py build_ext --inplace`
  ```python
  import torch
  import gemm_lowbit_ext  # This imports the compiled module

  a = torch.randn(10, 20, dtype=torch.half, device='cuda')  # Example tensor
  b = torch.randn(20, 30, dtype=torch.half, device='cuda')  # Example tensor
  c = torch.empty(10, 30, dtype=torch.half, device='cuda')  # Output tensor
  w_scale = 1.0  # Example scale factor
  x_scale = 1.0  # Example scale factor

  gemm_lowbit_ext.gemm_lowbit(a, b, c, w_scale, x_scale)
  print(c)  # View the result
  ```

  Implementation of BitLora!
  ```python
  import torch
  from bitnet import BitLora

  x = torch.randn(1, 12, 200)

  model = BitLora(in_features=200, out_features=200, rank=4, lora_alpha=1)

  out = model(x)

  print(out.shape)
  ```

  ```python
  import torch
  from bitnet import BitMamba

  x = torch.randint(0, 100, (2, 10))

  model = BitMamba(512, 100, 10, 6, return_tokens=True)

  output = model(x)

  print(output)

  print(output.shape)
  ```

  ```python
  import torch
  from bitnet.bit_moe import BitMoE

  x = torch.randn(2, 4, 8)

  model = BitMoE(8, 4, 2)

  output = model(x)

  print(output)
  ```

  MIT

  ```bibtex
  @misc{2310.11453,
  Author = {Hongyu Wang and Shuming Ma and Li Dong and Shaohan Huang and Huaijie Wang and Lingxiao Ma and Fan Yang and Ruiping Wang and Yi Wu and Furu Wei},
  Title = {BitNet: Scaling 1-bit Transformers for Large Language Models},
  Year = {2023},
  Eprint = {arXiv:2310.11453},
  }
  ```

  - [x] Double check BitLinear implementation and make sure it works exactly as in paper
  - [x] Implement training script for `BitNetTransformer`
  - [x] Train on Enwiki8, copy and past code and data from Lucidrains repos
  - [x] Benchmark performance
  - [x] Look into Straight Through Estimator for non-differentiable backprop
  - [x] Implement BitFeedForward
  - [x] Clean up codebase
  - [x] Add unit tests for each module
  - [x] Implement the new BitNet1.5b from the [paper](https://arxiv.org/abs/2402.17764)
  - [ ] Implement the BitNet15b in Cuda


pkgId: 7347f4b448456cf55e852b9849931b368c0a014d5633400c6a94ca3ffafdbd32
name: python-bitpapa-pay
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: Bitpapa Pay async python wrapper
url: https://pypi.org/project/bitpapa-pay/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitpapa-pay-0.1.16-1.src.rpm
checksum_type: sha256
description:
  **Docs**: https://apidocs.bitpapa.com/docs/apidocs/wvea40l9be95f-integracziya-bitpapa-pay



  Install bitpapa-pay

  ```
  pip install bitpapa-pay
  ```



  ```python
  import asyncio

  from bitpapa_pay import BitpapaPay


  async def main():
      bitpapa_pay = BitpapaPay(api_token="api_token")
      result = await bitpapa_pay.create_invoice("USDT", 100)
      print(result.model_dump())
      print(
          result.invoice.id,
          result.invoice.currency_code,
          result.invoice.amount,
          result.invoice.status,
          result.invoice.created_at,
          result.invoice.updated_at,
          result.invoice.url
      )
      result = await bitpapa_pay.get_invoices()
      for invoice in result.invoices:
          print(
              invoice.id,
              invoice.currency_code,
              invoice.amount,
              invoice.status,
              invoice.created_at,
              invoice.updated_at,
              invoice.url
          )
      result = await bitpapa_pay.get_exchange_rates_all()
      print(result)

      await bitpapa_pay.close()


  if __name__ == "__main__":
      asyncio.run(main())
  ```


pkgId: 256b480666a66780503c17c0d6d84ff099d33d07812ee96b1b024072d2586648
name: python-bitrix24-rest
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Easy way to communicate with bitrix24 portal over REST without OAuth
url: https://github.com/akopdev/bitrix24-python-rest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitrix24-rest-2.0.3-1.src.rpm
checksum_type: sha256
description:
  Easy way to communicate with bitrix24 portal over REST without OAuth 2.0



  Bitrix24 REST is an API wrapper for working with Bitrix24 REST API over webhooks.
  No OAuth 2.0 required. It's easy to use and super lightweight, with minimal dependencies.



  - Works with both cloud and on-premises versions of Bitrix24.
  - Super easy to setup. No OAuth 2.0 infrastructure required.
  - Built with data analysis in mind and fully compatible with Jupyter Notebook.
  - Fetch paginated data at once without hassle.
  - Works with large datasets and handles rate limits.



  ```
  pip install bitrix24-rest
  ```



  ```python
  from bitrix24 import Bitrix24

  bx24 = Bitrix24('https://example.bitrix24.com/rest/1/33olqeits4avuyqu')

  print(bx24.callMethod('crm.product.list'))
  ```

  In async mode:

  ```python
  import asyncio
  from bitrix24 import bitrix24

  async def main():
      bx24 = Bitrix24('https://example.bitrix24.com/rest/1/33olqeits4avuyqu')
      result = await bx24.callMethod('crm.product.list')
      print(result)

  asyncio.run(main())
  ```



  - [Using filters and additional parameters](docs/using-filters-and-additional-parameters.md)
  - [Working with large datasets](docs/working-with-large-datasets.md)
  - [Disabling certificate verification](docs/disabling-certificate-verification.md)



  List methods return all available items at once. For large collections of data use limits.



  New contributors and pull requests are welcome. If you have any questions or suggestions, feel free to open an issue.

  Code comes with makefile for easy code base management. You can check `make help` for more details.

  ```sh
  make init install # to create a local virtual environment and install dependencies

  make test # to run tests

  make lint # to run linter
  ```

  I suggest to use `make all` before committing your changes as it will run all the necessary checks.



  You can support this project by starring ⭐, sharing 📤, and contributing.

  You can also support the author by buying him a coffee ☕. Click sponsor button on the top of the page.


pkgId: 1910ee12b0ad81160d3a07b1a453c83aa13a49d2801323722f5c79562f3b4f35
name: python-bits
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: bits is a cli tool and pure Python library for Bitcoin
url: https://pypi.org/project/bits/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bits-0.2.1-1.src.rpm
checksum_type: sha256
description:
  `bits` is a cli tool and pure Python library for Bitcoin



  - Python 3.7+



  ```bash
  git clone https://github.com/jtraub91/bits.git
  cd bits/
  pip install .
  ```



  ```bash
  pip install -e .[dev]
  pre-commit install
  ```



  See the following for command line usage

  ```bash
  bits -h
  ```



  A configuration file is not strictly necessary, but may be leveraged, nominally located at `~/.bits/config.[toml|json]`, for overriding CLI defaults.

  See [conf/](/conf/) for default configuration files.



  [TOML](https://toml.io) is preferred for configuration files but is natively supported only on Python 3.11 and up; on the contrary, [JSON](https://www.json.org) is supported for all Python versions. Therefore, for all Python versions, if `~/.bits/config.json` is present, it will be used, but for Python 3.11+, if `~/.bits/config.toml` is present, it will be used instead.



  ```text
  1GjPvTLYLNodnBJ969DWHcqBMP3pa5tsV3
  ```



  MIT License

  Copyright (c) 2023 Jason Traub

  See `LICENSE.txt` for details.


pkgId: 588221779401612b02cc704c6f4c4c4741000ad838ab3cd5e258d7a042098ba3
name: python-bitsets
arch: src
version: 0.8.4
epoch: 0
release: 1
summary: Ordered subsets over a predefined domain
url: https://github.com/xflr6/bitsets
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitsets-0.8.4-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel|
  |Build| |Codecov| |Readthedocs-stable| |Readthedocs-latest|
  This package provides a memory-efficient pure-python **immutable ordered set
  data type** for working with large numbers of subsets from a predetermined pool
  of objects.
  Given a name and a tuple of hashable objects, the ``bitset()``-function returns
  a custom integer subclass for creating ordered subsets from the object pool.
  Each instance is a Python integer where the presence/absence of the *nth* pool
  item is its *nth* bit being set/unset (a.k.a. bit strings, powers of two, rank
  in *colexicographical* order).
  Being just a regular (arbitrary precision) integer with some convenience
  methods for translating between unique object collections and bit patterns
  allows to perform certain tasks in a more natural way, e.g. sorting a
  collection of sets lexicographically, or enumerating possible combinations in
  an ordered fashion.


pkgId: 2211ec33259f6e990c9875ef5275ee1f60afbd1fa05f5449eaa28ff1d592e7c0
name: python-bitsoframework
arch: src
version: 1.0.91
epoch: 0
release: 1
summary: A python companion library for the BITSO Framework
url: https://pypi.org/project/bitsoframework/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitsoframework-1.0.91-1.src.rpm
checksum_type: sha256
description:
  This project creates a shared database.
  If using docker it will create a shared network and volume that the other projects can connect to.
  Start bitsoframework by running `docker-compose -f local.yml up --build`
  If you are missing the network or volume you will see the following prompts:
    - create network with `docker network create bitso_local_network`
    - create volume with `docker volume create --name=bitso_local_db_volume`


pkgId: e0c56393cbbb5ae24fab8b1620e243d737fedca1920e84ca4d3fabe42110265b
name: python-bitsrun
arch: src
version: 3.7.1
epoch: 0
release: 1
summary: A headless login / logout script for 10.0.0.55
url: https://pypi.org/project/bitsrun/
rpm_license: WTFPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitsrun-3.7.1-1.src.rpm
checksum_type: sha256
description:
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Pre-commit](https://github.com/BITNP/bitsrun/actions/workflows/ci.yml/badge.svg)](https://github.com/BITNP/bitsrun/actions/workflows/ci.yml)
  [![PyPI Publish](https://github.com/BITNP/bitsrun/actions/workflows/python-publish.yml/badge.svg)](https://github.com/BITNP/bitsrun/actions/workflows/python-publish.yml)
  [![PyPI](https://img.shields.io/pypi/v/bitsrun)](https://pypi.org/project/bitsrun/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bitsrun)](https://pypi.org/project/bitsrun/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/bitsrun?color=orange)](https://pypi.org/project/bitsrun/)

  A headless login / logout script for 10.0.0.55 at BIT.

  | :sparkles: | Blazingly™ Fast Rust re-implementation of `bitsrun` available at [spencerwooo/bitsrun](https://github.com/spencerwooo/bitsrun-rs), if you require or prefer a single compiled executable (or 🦀 Rust). |
  | - |:-|



  You need at least **Python 3.8**. We recommend installing with `pipx`.

  ```shell
  python3 -m pip install --user pipx
  python3 -m pipx ensurepath
  ```

  After which, install `bitsrun` with `pipx`.

  ```shell
  pipx install bitsrun
  ```

  Alternatively, you can download a self-contained executable from [GitHub Releases](https://github.com/BITNP/bitsrun/releases/latest) if you are working from an environment that does not have internet access.





  Check login status of your device.

  ![bitsrun status](https://github.com/BITNP/bitsrun/assets/32114380/e877d6a9-120a-444a-b580-0a0fcac857ce)

  ```text
  Usage: bitsrun status [OPTIONS]

    Check current network login status.

  Options:
    --json / --no-json  Output in JSON format.
    --help  Show this message and exit.
  ```

  > **Note**: this is the output of `bitsrun status --help`.

  Login or logout with your username and password.

  ![bitsrun login](https://github.com/BITNP/bitsrun/assets/32114380/4ca8cd64-580b-4ab8-824f-0049f41f78bb)

  ```text
  Usage: bitsrun login/logout [OPTIONS]

    Log into or out of the BIT network.

  Options:
    -u, --username TEXT  Your username.
    -p, --password TEXT  Your password.
    -v, --verbose        Verbosely echo API response.
    --help               Show this message and exit.
  ```

  > **Note**: this is the output of `bitsrun login/logout --help`.



  Create new file named `bit-user.json`:

  ```json
  {
      "username": "xxxx",
      "password": "xxxx"
  }
  ```

  This file should be put under the following directory:

  - Windows: `%APPDATA%\bitsrun`
  - macOS and Linux: `~/.config/bitsrun` (Following the XDG spec)

  **On unix, set the file permission to `600`, i.e., only read/writeable by the owner:**

  ```shell
  chmod 600 path/to/bit-user.json
  ```

  Now you can simply call:

  ```shell
  bitsrun login
  bitsrun logout
  ```

  Besides, a system-wide configuration file is supported, and the location also depends on your platform.

  To list all possible paths for your system (including those only for backward compatibility), call:

  ```shell
  bitsrun config-paths
  ```



  ![raycast screenshot](https://user-images.githubusercontent.com/32114380/213919582-eff6d58f-1bd2-47b2-a5da-46dc6e2eaffa.png)

  Import the two Raycast scripts from [`./scripts`](./scripts/) and setup your config file in `~/.config/bit-user.json`. The script uses `/usr/bin/python3` by default, so you either need to install `bitsrun` with this Python interpreter or setup your own Python interpreter path in the script.



  Create virtual environment and install deps:

  ```shell
  python -m venv venv
  source venv/bin/activate
  pip install -e .
  ```

  Running CLI entry:

  ```shell
  python src/bitsrun/cli.py
  ```

  Build:

  ```shell
  pip install setuptools build
  python -m build
  ```



  - [Aloxaf/10_0_0_55_login](https://github.com/Aloxaf/10_0_0_55_login) - BIT 10.0.0.55 的登入与登出的 Python 实现 (This project's predecessor, archived)
  - [spencerwooo/bitsrun-rs](https://github.com/spencerwooo/bitsrun-rs) - A Rust implementation of `bitsrun`. (Rust)
  - [zu1k/srun](https://github.com/zu1k/srun) - Srun authentication system login tools. (Rust)
  - [Mmx233/BitSrunLoginGo](https://github.com/Mmx233/BitSrunLoginGo) - 深澜校园网登录脚本 Go 语言版 (Go)
  - [vouv/srun](https://github.com/vouv/srun) - An efficient client for BIT campus network. (Go)



  [WTFPL License](LICENSE)


pkgId: 026b0920d4577cf942a47e8e2a73cb6d906e2f60a73c49bf095d89678d185395
name: python-bitstring
arch: src
version: 4.2.3
epoch: 0
release: 1
summary: Simple construction, analysis and modification of binary data.
url: https://pypi.org/project/bitstring/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitstring-4.2.3-1.src.rpm
checksum_type: sha256
description:
  > [!NOTE]
  > To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md).

  * Efficiently store and manipulate binary data in idiomatic Python.
  * Create bitstrings from hex, octal, binary, files, formatted strings, bytes, integers and floats of different endiannesses.
  * Powerful binary packing and unpacking functions.
  * Bit-level slicing, joining, searching, replacing and more.
  * Create and manipulate arrays of fixed-length bitstrings.
  * Read from and interpret bitstrings as streams of binary data.
  * Rich API - chances are that whatever you want to do there's a simple and elegant way of doing it.
  * Open source software, released under the MIT licence.

  Extensive documentation for the bitstring module is available.
  Some starting points are given below:
  * [Overview](https://bitstring.readthedocs.io/en/stable/index.html)
  * [Quick Reference](https://bitstring.readthedocs.io/en/stable/quick_reference.html)
  * [Full Reference](https://bitstring.readthedocs.io/en/stable/reference.html)
  There is also an introductory walkthrough notebook on [binder](https://mybinder.org/v2/gh/scott-griffiths/bitstring/main?labpath=doc%2Fwalkthrough.ipynb).


  ```
  $ pip install bitstring
  ```

  ```pycon
  >>> from bitstring import Bits, BitArray, BitStream, pack
  >>> a = BitArray(bin='00101')
  >>> b = Bits(a_file_object)
  >>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
  >>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
  >>> e = pack('<16h', *range(16))
  ```

  ```pycon
  >>> a = BitArray('0x3348')
  >>> a.hex, a.bin, a.uint, a.float, a.bytes
  ('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
  >>> a[10:3:-1].bin
  '0101100'
  >>> '0b100' + 3*a
  BitArray('0x866906690669, 0b000')
  ```

  ```pycon
  >>> b = BitStream('0x160120f')
  >>> b.read(12).hex
  '160'
  >>> b.pos = 0
  >>> b.read('uint12')
  352
  >>> b.readlist('uint12, bin3')
  [288, '111']
  ```

  ```pycon
  >>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
  >>> c.find('0x48')
  (8,)
  >>> c.replace('0b001', '0xabc')
  >>> c.insert('0b0000', pos=3)
  >>> del c[12:16]
  ```

  ```pycon
  >>> from bitstring import Array
  >>> a = Array('uint7', [9, 100, 3, 1])
  >>> a.data
  BitArray('0x1390181')
  >>> a[::2] *= 5
  >>> a
  Array('uint7', [45, 100, 15, 1])
  ```
  <sub>Copyright (c) 2006 - 2024 Scott Griffiths</sub>


pkgId: 5253339938d346cbe5b73063e3862f9e82aa184e80ab891d6f1c3c37933fea16
name: python-bitstruct
arch: src
version: 8.19.0
epoch: 0
release: 1
url: https://github.com/eerimoq/bitstruct
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitstruct-8.19.0-1.src.rpm
checksum_type: sha256
summary:
  This module performs conversions between Python values and C bit field structs represented as Python byte strings.

description:
  This module is intended to have a similar interface as the python
  struct module, but working on bits instead of primitive data types
  (char, int, ...).
  Project homepage: https://github.com/eerimoq/bitstruct
  Documentation: https://bitstruct.readthedocs.io


pkgId: 127a125ae1602e6712ae563bd51ec1618ba33f4ed5f1ec1dc231bf5dbb65a301
name: python-bittrade-kraken-rest
arch: src
version: 0.13.15
epoch: 0
release: 1
summary: Kraken REST library
url: https://github.com/TechSpaceAsia/bittrade-kraken-rest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bittrade-kraken-rest-0.13.15-1.src.rpm
checksum_type: sha256
description:
  TLDR; Don't agree to pass your API secret to third-party code; instead sign the requests yourself, with your own code. It's safer.
  This library doesn't want to ever access your Kraken secret keys.
  Most libraries expect you to provide your api key and secret. I'm not comfortable doing that with third-party code, even open sourced.
  Here instead, the library prepares the request, which you then sign using your own code and the library finishes the job. It has NO access to your secret.
  Thankfully this is quite straightforward: you need to implement a `sign(x: tuple[PreparedRequest, str, dict[str, Any]]) -> PreparedRequest` method which sets the correct headers. Below is an example of such a signature function:
  ```python
  from os import getenv
  import urllib, hmac, base64, hashlib
  from pathlib import Path

  def generate_kraken_signature(urlpath, data, secret):
      post_data = urllib.parse.urlencode(data)
      encoded = (str(data["nonce"]) + post_data).encode()
      message = urlpath.encode() + hashlib.sha256(encoded).digest()
      mac = hmac.new(base64.b64decode(secret), message, hashlib.sha512)
      signature_digest = base64.b64encode(mac.digest())
      return signature_digest.decode()

  def sign(x: tuple[PreparedRequest, str, dict[str, Any]]):
      request, url, data = x
      request.headers["API-Key"] = Path("./config_local/key").read_text()
      request.headers["API-Sign"] = generate_kraken_signature(
          url, data, Path("./config_local/secret").read_text()
      )
      return request
  ```
  With that in place, a observable pipe will get you the result you need:
  ```python
  from bittrade_kraken_rest import get_websockets_token_request, get_websockets_token_result
  from reactivex import operators
  result = get_websockets_token_request().pipe(
      operators.map(sign),
      get_websockets_token_result()
  ).run()
  ```

  ```python
  from os import getenv
  import urllib, hmac, base64, hashlib
  from pathlib import Path
  from bittrade_kraken_rest import get_websockets_token_request, get_websockets_token_result
  from reactivex import operators

  def generate_kraken_signature(urlpath, data, secret):
      post_data = urllib.parse.urlencode(data)
      encoded = (str(data["nonce"]) + post_data).encode()
      message = urlpath.encode() + hashlib.sha256(encoded).digest()
      mac = hmac.new(base64.b64decode(secret), message, hashlib.sha512)
      signature_digest = base64.b64encode(mac.digest())
      return signature_digest.decode()

  def sign(x: tuple[PreparedRequest, str, dict[str, Any]]):
      request, url, data = x
      request.headers["API-Key"] = Path("./config_local/key").read_text()
      request.headers["API-Sign"] = generate_kraken_signature(
          url, data, Path("./config_local/secret").read_text()
      )
      return request
  result = get_websockets_token_request().pipe(
      operators.map(sign),
      get_websockets_token_result()
  ).run()
  ```
  *The above example is complete, it should run as is*

  The above examples use `.run()` to trigger the observable subscription but Observables make it very easy to create pipes, retries and more. All operators can be found on the [RxPy read the docs](https://rxpy.readthedocs.io/en/latest/).

  ```
  pytest
  ```
  Note that integration tests require a valid key/secret pair saved as `key` and `secret` files in a `.config_local` folder placed at the root of the repo.

  The CLI has been moved to [its own repo](https://github.com/TechSpaceAsia/bittrade-kraken-cli)


pkgId: 8e6a205acb8282400ee447713abdf31fb3773605de8985d66588fb1d15507f3d
name: python-bitvavo-api-upgraded
arch: src
version: 1.16.0
epoch: 0
release: 1
summary: A unit-tested fork of the Bitvavo API
url: https://pypi.org/project/bitvavo-api-upgraded/
rpm_license: ISC License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitvavo-api-upgraded-1.16.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <br>
    <a href="https://bitvavo.com"><img src="https://bitvavo.com/assets/static/ext/logo-shape.svg" width="100" title="Bitvavo Logo"></a>
  </p>

  This is the python wrapper for the Bitvavo API. This project can be used to
  build your own projects which interact with the Bitvavo platform. Every function
  available on the API can be called through a REST request or over websockets.
  For info on the specifics of every parameter consult the [Bitvavo API
  documentation](https://docs.bitvavo.com/)
  - Getting started
    [REST](https://github.com/bitvavo/python-bitvavo-api#getting-started)
    [Websocket](https://github.com/bitvavo/python-bitvavo-api#getting-started-1)
  - General
    - Time [REST](https://github.com/bitvavo/python-bitvavo-api#get-time)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-time-1)
    - Markets [REST](https://github.com/bitvavo/python-bitvavo-api#get-markets)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-markets-1)
    - Assets [REST](https://github.com/bitvavo/python-bitvavo-api#get-assets)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-assets-1)
  - Market Data
    - Book
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-book-per-market)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-book-per-market-1)
    - Public Trades
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-trades-per-market)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-trades-per-market-1)
    - Candles
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-candles-per-market)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-candles-per-market-1)
    - Price Ticker
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-price-ticker)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-price-ticker-1)
    - Book Ticker
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-book-ticker)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-book-ticker-1)
    - 24 Hour Ticker
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-24-hour-ticker)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-24-hour-ticker-1)
  - Private
    - Place Order
      [REST](https://github.com/bitvavo/python-bitvavo-api#place-order)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#place-order-1)
    - Update Order
      [REST](https://github.com/bitvavo/python-bitvavo-api#update-order)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#update-order-1)
    - Get Order [REST](https://github.com/bitvavo/python-bitvavo-api#get-order)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-order-1)
    - Cancel Order
      [REST](https://github.com/bitvavo/python-bitvavo-api#cancel-order)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#cancel-order-1)
    - Get Orders [REST](https://github.com/bitvavo/python-bitvavo-api#get-orders)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-orders-1)
    - Cancel Orders
      [REST](https://github.com/bitvavo/python-bitvavo-api#cancel-orders)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#cancel-orders-1)
    - Orders Open
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-orders-open)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-orders-open-1)
    - Trades [REST](https://github.com/bitvavo/python-bitvavo-api#get-trades)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-trades-1)
    - Account [REST](https://github.com/bitvavo/python-bitvavo-api#get-account)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-account-1)
    - Balance [REST](https://github.com/bitvavo/python-bitvavo-api#get-balance)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-balance-1)
    - Deposit Assets
      [REST](https://github.com/bitvavo/python-bitvavo-api#deposit-assets)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#deposit-assets-1)
    - Withdraw Assets
      [REST](https://github.com/bitvavo/python-bitvavo-api#withdraw-assets)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#withdraw-assets-1)
    - Deposit History
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-deposit-history)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-deposit-history-1)
    - Withdrawal History
      [REST](https://github.com/bitvavo/python-bitvavo-api#get-withdrawal-history)
      [Websocket](https://github.com/bitvavo/python-bitvavo-api#get-withdrawal-history-1)
  - [Subscriptions](https://github.com/bitvavo/python-bitvavo-api#subscriptions)
    - [Ticker
      Subscription](https://github.com/bitvavo/python-bitvavo-api#ticker-subscription)
    - [Ticker 24 Hour
      Subscription](https://github.com/bitvavo/python-bitvavo-api#ticker-24-hour-subscription)
    - [Account
      Subscription](https://github.com/bitvavo/python-bitvavo-api#account-subscription)
    - [Candles
      Subscription](https://github.com/bitvavo/python-bitvavo-api#candles-subscription)
    - [Trades
      Subscription](https://github.com/bitvavo/python-bitvavo-api#trades-subscription)
    - [Book
      Subscription](https://github.com/bitvavo/python-bitvavo-api#book-subscription)
    - [Book subscription with local
      copy](https://github.com/bitvavo/python-bitvavo-api#book-subscription-with-local-copy)

  ```
  pip install python-bitvavo-api
  ```

  Bitvavo uses a weight based rate limiting system, with an allowed limit of 1000
  per IP or API key each minute. Please inspect each endpoint in the [Bitvavo API
  documentation](https://docs.bitvavo.com/) to see the weight. Failure to respect
  the rate limit will result in an IP or API key ban. Since the remaining limit is
  returned in the header on each REST request, the remaining limit is tracked
  locally and can be requested through:
  ```
  limit = bitvavo.getRemainingLimit()
  ```
  The websocket functions however do not return a remaining limit, therefore the
  limit is only updated locally once a ban has been issued.

  The general convention used in all functions (both REST and websockets), is that
  all optional parameters are passed as an dictionary, while required parameters
  are passed as separate values. Only when [placing
  orders](https://github.com/bitvavo/python-bitvavo-api#place-order) some of the
  optional parameters are required, since a limit order requires more information
  than a market order. The returned responses are all converted to a dictionary as
  well, such that `response['<key>'] = '<value>'`.

  The API key and secret are required for private calls and optional for public
  calls. The access window and debugging parameter are optional for all calls. The
  access window is used to determine whether the request arrived within time, the
  value is specified in milliseconds. You can use the
  [time](https://github.com/bitvavo/python-bitvavo-api#get-time) function to
  synchronize your time to our server time if errors arise. REST url and WS url
  can be used to set a different endpoint (for testing purposes). Debugging should
  be set to true when you want to log additional information and full responses.
  Any parameter can be omitted, private functions will return an error when the
  api key and secret have not been set.
  ```python
  from bitvavo_api_upgraded.bitvavo import Bitvavo
  bitvavo = Bitvavo(
      {
          "APIKEY": "<APIKEY>",
          "APISECRET": "<APISECRET>",
          "RESTURL": "https://api.bitvavo.com/v2",
          "WSURL": "wss://ws.bitvavo.com/v2/",
          "ACCESSWINDOW": 10000,
          "DEBUGGING": False,
      }
  )
  ```


  ```python
  response = bitvavo.time()
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"time": 1543397021396}
  ```
  </details>

  ```python

  response = bitvavo.markets({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "market": "ADA-BTC",
      "status": "trading",
      "base": "ADA",
      "quote": "BTC",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "100",
      "minOrderInQuoteAsset": "0.001",
      "orderTypes": ["market", "limit"],
  }
  {
      "market": "ADA-EUR",
      "status": "trading",
      "base": "ADA",
      "quote": "EUR",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "100",
      "minOrderInQuoteAsset": "10",
      "orderTypes": ["market", "limit"],
  }
  {
      "market": "AE-BTC",
      "status": "trading",
      "base": "AE",
      "quote": "BTC",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "10",
      "minOrderInQuoteAsset": "0.001",
      "orderTypes": ["market", "limit"],
  }
  {
      "market": "AE-EUR",
      "status": "trading",
      "base": "AE",
      "quote": "EUR",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "10",
      "minOrderInQuoteAsset": "10",
      "orderTypes": ["market", "limit"],
  }
  ```
  </details>

  ```python

  response = bitvavo.assets({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "symbol": "ADA",
          "name": "Cardano",
          "decimals": 6,
          "depositFee": "0",
          "depositConfirmations": 20,
          "depositStatus": "OK",
          "withdrawalFee": "0.2",
          "withdrawalMinAmount": "0.2",
          "withdrawalStatus": "OK",
          "networks": ["Mainnet"],
          "message": "",
      },
      {
          "symbol": "AE",
          "name": "Aeternity",
          "decimals": 8,
          "depositFee": "0",
          "depositConfirmations": 30,
          "depositStatus": "OK",
          "withdrawalFee": "2",
          "withdrawalMinAmount": "2",
          "withdrawalStatus": "OK",
          "networks": ["Mainnet"],
          "message": "",
      },
      {
          "symbol": "AION",
          "name": "Aion",
          "decimals": 8,
          "depositFee": "0",
          "depositConfirmations": 0,
          "depositStatus": "",
          "withdrawalFee": "3",
          "withdrawalMinAmount": "3",
          "withdrawalStatus": "",
          "networks": ["Mainnet"],
          "message": "",
      },
      {
          "symbol": "ANT",
          "name": "Aragon",
          "decimals": 8,
          "depositFee": "0",
          "depositConfirmations": 30,
          "depositStatus": "OK",
          "withdrawalFee": "2",
          "withdrawalMinAmount": "2",
          "withdrawalStatus": "OK",
          "networks": ["Mainnet"],
          "message": "",
      },
  ]
  ```
  </details>


  ```python

  response = bitvavo.book("BTC-EUR", {})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "market": "BTC-EUR",
      "nonce": 26393,
      "bids": [
          ["3008.8", "1.47148675"],
          ["3008.3", "1.10515032"],
          ["3007.7", "1.38627613"],
          ["3007.2", "0.72343843"],
          ["3006.7", "0.96668815"],
          ["3006.2", "3.50846635"],
      ],
      "asks": [
          ["3009.2", "2.74009412"],
          ["3011.3", "3.03788636"],
          ["3013.1", "3.91270989"],
          ["3015.1", "4.33891895"],
          ["3016", "1.34888815"],
          ["3016.5", "1.95726644"],
      ],
  }
  ```
  </details>

  ```python

  response = bitvavo.publicTrades("BTC-EUR", {})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
    {
      "id": "041689b3-cbb6-49ec-9964-2fb2d353dd1b",
      "timestamp": 1565672192018,
      "amount": "0.12735922",
      "price": "10147",
      "side": "sell"
    },
    {
      "id": "fb1712f2-e183-457c-b9e5-ff0d31fccd1f",
      "timestamp": 1565672192014,
      "amount": "0.08703703",
      "price": "10149",
      "side": "sell"
    },
    {
      "id": "b8cf5e20-65ca-4f45-a94c-44b7cb3952a5",
      "timestamp": 1565672192009,
      "amount": "0.0979994",
      "price": "10151",
      "side": "sell"
    },
    {
      "id": "d10cc7ec-a735-4d5c-8169-c3099f8b5003",
      "timestamp": 1565672144747,
      "amount": "0.01975188",
      "price": "10151",
      "side": "sell"
    }
  ]
  ```
  </details>

  ```python

  response = bitvavo.candles("BTC-EUR", "1h", {})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      [1548669600000, "3012.9", "3015.8", "3000", "3012.9", "8"],
      [1548669600000, "3012.9", "3015.8", "3000", "3012.9", "8"],
      [1548669600000, "3012.9", "3015.8", "3000", "3012.9", "8"],
      [1548417600000, "3124", "3125.1", "3124", "3124", "0.1"],
      [1548237600000, "3143", "3143.3", "3141.1", "3143", "60.67250851"],
  ]
  ```
  </details>

  ```python

  response = bitvavo.tickerPrice({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {"market": "EOS-EUR", "price": "2.0142"},
      {"market": "XRP-EUR", "price": "0.27848"},
      {"market": "ETH-EUR", "price": "99.877"},
      {"market": "IOST-EUR", "price": "0.005941"},
      {"market": "BCH-EUR", "price": "106.57"},
      {"market": "BTC-EUR", "price": "3008.9"},
      {"market": "STORM-EUR", "price": "0.0025672"},
      {"market": "EOS-BTC", "price": "0.00066289"},
  ]
  ```
  </details>

  ```python

  response = bitvavo.tickerBook({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "market": "ZIL-BTC",
          "bid": "0.00000082",
          "ask": "0.00000083",
          "bidSize": "13822.00651664",
          "askSize": "5743.88893286",
      },
      {
          "market": "ZIL-EUR",
          "bid": "0.0082973",
          "ask": "0.0084058",
          "bidSize": "19586.15862762",
          "askSize": "19048.86640562",
      },
      {
          "market": "ZRX-BTC",
          "bid": "0.00001625",
          "ask": "0.00001629",
          "bidSize": "823.87743487",
          "askSize": "868.23901671",
      },
      {
          "market": "ZRX-EUR",
          "bid": "0.16443",
          "ask": "0.16498",
          "bidSize": "898.35016343",
          "askSize": "419.16696625",
      },
  ]
  ```
  </details>

  ```python

  response = bitvavo.ticker24h({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "market": "XVG-EUR",
          "open": "0.0045692",
          "high": "0.0045853",
          "low": "0.0043599",
          "last": "0.0044047",
          "volume": "594786.9689017",
          "volumeQuote": "2648.07",
          "bid": "0.0043493",
          "bidSize": "1561220.43836043",
          "ask": "0.004453",
          "askSize": "1457312.74672114",
          "timestamp": 1565684835077,
      },
      {
          "market": "ZIL-EUR",
          "open": "0.0081178",
          "high": "0.0084196",
          "low": "0.0077389",
          "last": "0.0084071",
          "volume": "950455.78568402",
          "volumeQuote": "7687.71",
          "bid": "0.008294",
          "bidSize": "19593.90088084",
          "ask": "0.0084",
          "askSize": "19048.86640562",
          "timestamp": 1565684834952,
      },
      {
          "market": "ZRX-EUR",
          "open": "0.1731",
          "high": "0.1731",
          "low": "0.16426",
          "last": "0.16477",
          "volume": "22486.29651877",
          "volumeQuote": "3727.45",
          "bid": "0.16436",
          "bidSize": "898.75082725",
          "ask": "0.16476",
          "askSize": "419.31541176",
          "timestamp": 1565684835335,
      },
  ]
  ```
  </details>


  When placing an order, make sure that the correct optional parameters are set.
  For a limit order it is required to set both the amount and price. A market
  order is valid if either amount or amountQuote is set.
  ```python




  response = bitvavo.placeOrder(
      "BTC-EUR", "buy", "limit", {"amount": "1", "price": "3000"}
  )
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "orderId": "5444f908-67c4-4c5d-a138-7e834b94360e",
      "market": "BTC-EUR",
      "created": 1548671550610,
      "updated": 1548671550610,
      "status": "new",
      "side": "buy",
      "orderType": "limit",
      "amount": "1",
      "amountRemaining": "1",
      "price": "3000",
      "onHold": "3007.5",
      "onHoldCurrency": "EUR",
      "filledAmount": "0",
      "filledAmountQuote": "0",
      "feePaid": "0",
      "feeCurrency": "EUR",
      "fills": [],
      "selfTradePrevention": "decrementAndCancel",
      "visible": true,
      "timeInForce": "GTC",
      "postOnly": false,
  }
  ```
  </details>

  When updating an order make sure that at least one of the optional parameters
  has been set. Otherwise nothing can be updated.
  ```python



  response = bitvavo.updateOrder(
      "BTC-EUR", "5444f908-67c4-4c5d-a138-7e834b94360e", {"amount": "1.1"}
  )
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "orderId": "5444f908-67c4-4c5d-a138-7e834b94360e",
      "market": "BTC-EUR",
      "created": 1548671550610,
      "updated": 1548671831685,
      "status": "new",
      "side": "buy",
      "orderType": "limit",
      "amount": "1.1",
      "amountRemaining": "1.1",
      "price": "3000",
      "onHold": "3308.25",
      "onHoldCurrency": "EUR",
      "filledAmount": "0",
      "filledAmountQuote": "0",
      "feePaid": "0",
      "feeCurrency": "EUR",
      "fills": [],
      "selfTradePrevention": "decrementAndCancel",
      "visible": true,
      "timeInForce": "GTC",
      "postOnly": false,
  }
  ```
  </details>

  ```python
  response = bitvavo.getOrder("BTC-EUR", "5444f908-67c4-4c5d-a138-7e834b94360e")
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "orderId": "5444f908-67c4-4c5d-a138-7e834b94360e",
      "market": "BTC-EUR",
      "created": 1548671550610,
      "updated": 1548671550610,
      "status": "new",
      "side": "buy",
      "orderType": "limit",
      "amount": "1",
      "amountRemaining": "1",
      "price": "3000",
      "onHold": "3007.5",
      "onHoldCurrency": "EUR",
      "filledAmount": "0",
      "filledAmountQuote": "0",
      "feePaid": "0",
      "feeCurrency": "EUR",
      "fills": [],
      "selfTradePrevention": "decrementAndCancel",
      "visible": true,
      "timeInForce": "GTC",
      "postOnly": false,
  }
  ```
  </details>

  ```python
  response = bitvavo.cancelOrder("BTC-EUR", "5986db7b-8d6e-4577-8003-22f363fb3626")
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"orderId": "5986db7b-8d6e-4577-8003-22f363fb3626"}
  ```
  </details>

  Returns the same as get order, but can be used to return multiple orders at
  once.
  ```python

  response = bitvavo.getOrders("BTC-EUR", {})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "orderId": "bad72641-7755-464c-8dcb-7c1d59b142ab",
          "market": "BTC-EUR",
          "created": 1548670024870,
          "updated": 1548670024870,
          "status": "partiallyFilled",
          "side": "buy",
          "orderType": "limit",
          "amount": "1",
          "amountRemaining": "0.5",
          "price": "3000",
          "onHold": "1504.5",
          "onHoldCurrency": "EUR",
          "filledAmount": "0.5",
          "filledAmountQuote": "1500",
          "feePaid": "3",
          "feeCurrency": "EUR",
          "fills": [
              {
                  "id": "108c3633-0276-4480-a902-17a01829deae",
                  "timestamp": 1548671992530,
                  "amount": "0.5",
                  "price": "3000",
                  "taker": false,
                  "fee": "3",
                  "feeCurrency": "EUR",
                  "settled": true,
              }
          ],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
      {
          "orderId": "da1d8330-d6b7-4753-800a-01ad510a679b",
          "market": "BTC-EUR",
          "created": 1548666570234,
          "updated": 1548666570234,
          "status": "filled",
          "side": "sell",
          "orderType": "limit",
          "amount": "0.1",
          "amountRemaining": "0",
          "price": "4000",
          "onHold": "0",
          "onHoldCurrency": "BTC",
          "filledAmount": "0.1",
          "filledAmountQuote": "400",
          "feePaid": "0.8",
          "feeCurrency": "EUR",
          "fills": [
              {
                  "id": "79e4bf2f-4fac-4895-9bb2-a5c9c6e2ff3f",
                  "timestamp": 1548666712071,
                  "amount": "0.1",
                  "price": "4000",
                  "taker": false,
                  "fee": "0.8",
                  "feeCurrency": "EUR",
                  "settled": true,
              }
          ],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
  ]
  ```
  </details>

  Cancels all orders in a market. If no market is specified, all orders of an
  account will be canceled.
  ```python

  response = bitvavo.cancelOrders({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
    {
      "orderId": "4f9a809b-859f-4d8d-97b3-037113cdf2d0"
    },
    {
      "orderId": "95313ae5-ad65-4430-a0fb-63591bbc337c".
    },
    {
      "orderId": "2465c3ab-5ae2-4d4d-bec7-345f51b3494d"
    },
  ]
  ```
  </details>

  Returns all orders which are not filled or canceled.
  ```python

  response = bitvavo.ordersOpen({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "orderId": "bad72641-7755-464c-8dcb-7c1d59b142ab",
          "market": "BTC-EUR",
          "created": 1548670024870,
          "updated": 1548670024870,
          "status": "partiallyFilled",
          "side": "buy",
          "orderType": "limit",
          "amount": "1",
          "amountRemaining": "0.5",
          "price": "3000",
          "onHold": "1504.5",
          "onHoldCurrency": "EUR",
          "filledAmount": "0.5",
          "filledAmountQuote": "1500",
          "feePaid": "3",
          "feeCurrency": "EUR",
          "fills": [
              {
                  "id": "108c3633-0276-4480-a902-17a01829deae",
                  "timestamp": 1548671992530,
                  "amount": "0.5",
                  "price": "3000",
                  "taker": false,
                  "fee": "3",
                  "feeCurrency": "EUR",
                  "settled": true,
              }
          ],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
      {
          "orderId": "7586d610-2732-4ee6-8516-bed18cfc853b",
          "market": "BTC-EUR",
          "created": 1548670088749,
          "updated": 1548670088749,
          "status": "new",
          "side": "buy",
          "orderType": "limit",
          "amount": "1",
          "amountRemaining": "1",
          "price": "3000",
          "onHold": "3007.5",
          "onHoldCurrency": "EUR",
          "filledAmount": "0",
          "filledAmountQuote": "0",
          "feePaid": "0",
          "feeCurrency": "EUR",
          "fills": [],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
  ]
  ```
  </details>

  Returns all trades within a market for this account.
  ```python

  response = bitvavo.trades("BTC-EUR", {})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "id": "108c3633-0276-4480-a902-17a01829deae",
          "timestamp": 1548671992530,
          "market": "BTC-EUR",
          "side": "buy",
          "amount": "0.5",
          "price": "3000",
          "taker": false,
          "fee": "3",
          "feeCurrency": "EUR",
          "settled": true,
      },
      {
          "id": "79e4bf2f-4fac-4895-9bb2-a5c9c6e2ff3f",
          "timestamp": 1548666712071,
          "market": "BTC-EUR",
          "side": "sell",
          "amount": "0.1",
          "price": "4000",
          "taker": false,
          "fee": "0.8",
          "feeCurrency": "EUR",
          "settled": true,
      },
      {
          "id": "102486d3-5b72-4fa2-89cf-84c934edb7ae",
          "timestamp": 1548666561486,
          "market": "BTC-EUR",
          "side": "sell",
          "amount": "0.1",
          "price": "4000",
          "taker": true,
          "fee": "1",
          "feeCurrency": "EUR",
          "settled": true,
      },
  ]
  ```
  </details>

  Returns the fee tier for this account.
  ```python
  response = bitvavo.account()
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"fees": {"taker": "0.0025", "maker": "0.0015", "volume": "100.00"}}
  ```
  </details>

  Returns the balance for this account.
  ```python

  response = bitvavo.balance({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {"symbol": "EUR", "available": "2599.95", "inOrder": "2022.65"},
      {"symbol": "BTC", "available": "1.65437", "inOrder": "0.079398"},
      {"symbol": "ADA", "available": "4.8", "inOrder": "0"},
      {"symbol": "BCH", "available": "0.00952811", "inOrder": "0"},
      {"symbol": "BSV", "available": "0.00952811", "inOrder": "0"},
  ]
  ```
  </details>

  Returns the address which can be used to deposit funds.
  ```python
  response = bitvavo.depositAssets("BTC")
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"address": "BitcoinAddress"}
  ```
  </details>

  Can be used to withdraw funds from Bitvavo.
  ```python

  response = bitvavo.withdrawAssets("BTC", "1", "BitcoinAddress", {})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"success": True, "symbol": "BTC", "amount": "1"}
  ```
  </details>

  Returns the deposit history of your account.
  ```python

  response = bitvavo.depositHistory({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "timestamp": 1521550025000,
          "symbol": "EUR",
          "amount": "1",
          "fee": "0",
          "status": "completed",
          "address": "NL12RABO324234234",
      },
      {
          "timestamp": 1511873910000,
          "symbol": "BTC",
          "amount": "0.099",
          "fee": "0",
          "status": "completed",
          "txId": "0c6497e608212a516b8218674cb0ca04f65b67a00fe8bddaa1ecb03e9b029255",
      },
  ]
  ```
  </details>

  Returns the withdrawal history of an account.
  ```python

  response = bitvavo.withdrawalHistory({})
  print(response)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "timestamp": 1548425559000,
          "symbol": "BTC",
          "amount": "0.09994",
          "fee": "0.00006",
          "status": "awaiting_processing",
          "address": "1CqtG5z55x7bYD5GxsAXPx59DEyujs4bjm",
      },
      {
          "timestamp": 1548409721000,
          "symbol": "EUR",
          "amount": "50",
          "fee": "0",
          "status": "completed",
          "address": "NL123BIM",
      },
      {
          "timestamp": 1537803091000,
          "symbol": "BTC",
          "amount": "0.01939",
          "fee": "0.00002",
          "status": "completed",
          "txId": "da2299c86fce67eb899aeaafbe1f81cf663a3850cf9f3337c92b2d87945532db",
          "address": "3QpyxeA7yWWsSURXEmuBBzHpxjqn7Rbyme",
      },
  ]
  ```
  </details>

  All requests which can be done through REST requests can also be performed over
  websockets. Bitvavo also provides six
  [subscriptions](https://github.com/bitvavo/python-bitvavo-api#subscriptions). If
  subscribed to these, updates specific for that type/market are pushed
  immediately.

  The websocket object should be intialised through the `newWebsocket()` function.
  After which a callback for the errors should be set. After this any desired
  function can be called. Finally the main thread should be kept alive for as long
  as you want the socket to stay open. This can be achieved through a simple
  `while()` loop, where the remaining limit is checked. This is in case a ban has
  been issued, otherwise the websocket object will keep trying to reconnect, while
  our servers keep closing the connection.
  ```python
  def errorCallback(error):
      print("Handle error here", error)
  def ownCallback(response):
      print("Handle function response here", response)
  websocket = bitvavo.newWebsocket()
  websocket.setErrorCallback(errorCallback)


  limit = bitvavo.getRemainingLimit()
  try:
      while limit > 0:
          time.sleep(0.5)
          limit = bitvavo.getRemainingLimit()
  except KeyboardInterrupt:
      websocket.closeSocket()
  ```
  The api key and secret are copied from the bitvavo object. Therefore if you want
  to use the private portion of the websockets API, you should set both the key
  and secret as specified in [REST
  requests](https://github.com/bitvavo/python-bitvavo-api#rest-requests).


  ```python
  websocket.time(ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"time": 1543397021396}
  ```
  </details>

  ```python

  websocket.markets({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "market": "ADA-BTC",
      "status": "trading",
      "base": "ADA",
      "quote": "BTC",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "100",
      "minOrderInQuoteAsset": "0.001",
      "orderTypes": ["market", "limit"],
  }
  {
      "market": "ADA-EUR",
      "status": "trading",
      "base": "ADA",
      "quote": "EUR",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "100",
      "minOrderInQuoteAsset": "10",
      "orderTypes": ["market", "limit"],
  }
  {
      "market": "AE-BTC",
      "status": "trading",
      "base": "AE",
      "quote": "BTC",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "10",
      "minOrderInQuoteAsset": "0.001",
      "orderTypes": ["market", "limit"],
  }
  {
      "market": "AE-EUR",
      "status": "trading",
      "base": "AE",
      "quote": "EUR",
      "pricePrecision": 5,
      "minOrderInBaseAsset": "10",
      "minOrderInQuoteAsset": "10",
      "orderTypes": ["market", "limit"],
  }
  ```
  </details>

  ```python

  websocket.assets({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "symbol": "ADA",
          "name": "Cardano",
          "decimals": 6,
          "depositFee": "0",
          "depositConfirmations": 20,
          "depositStatus": "OK",
          "withdrawalFee": "0.2",
          "withdrawalMinAmount": "0.2",
          "withdrawalStatus": "OK",
          "networks": ["Mainnet"],
          "message": "",
      },
      {
          "symbol": "AE",
          "name": "Aeternity",
          "decimals": 8,
          "depositFee": "0",
          "depositConfirmations": 30,
          "depositStatus": "OK",
          "withdrawalFee": "2",
          "withdrawalMinAmount": "2",
          "withdrawalStatus": "OK",
          "networks": ["Mainnet"],
          "message": "",
      },
      {
          "symbol": "AION",
          "name": "Aion",
          "decimals": 8,
          "depositFee": "0",
          "depositConfirmations": 0,
          "depositStatus": "",
          "withdrawalFee": "3",
          "withdrawalMinAmount": "3",
          "withdrawalStatus": "",
          "networks": ["Mainnet"],
          "message": "",
      },
      {
          "symbol": "ANT",
          "name": "Aragon",
          "decimals": 8,
          "depositFee": "0",
          "depositConfirmations": 30,
          "depositStatus": "OK",
          "withdrawalFee": "2",
          "withdrawalMinAmount": "2",
          "withdrawalStatus": "OK",
          "networks": ["Mainnet"],
          "message": "",
      },
  ]
  ```
  </details>

  ```python

  websocket.book("BTC-EUR", {}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "market": "BTC-EUR",
      "nonce": 26393,
      "bids": [
          ["3008.8", "1.47148675"],
          ["3008.3", "1.10515032"],
          ["3007.7", "1.38627613"],
          ["3007.2", "0.72343843"],
          ["3006.7", "0.96668815"],
          ["3006.2", "3.50846635"],
      ],
      "asks": [
          ["3009.2", "2.74009412"],
          ["3011.3", "3.03788636"],
          ["3013.1", "3.91270989"],
          ["3015.1", "4.33891895"],
          ["3016", "1.34888815"],
          ["3016.5", "1.95726644"],
      ],
  }
  ```
  </details>

  ```python

  websocket.publicTrades("BTC-EUR", {}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
    {
      "id": "041689b3-cbb6-49ec-9964-2fb2d353dd1b",
      "timestamp": 1565672192018,
      "amount": "0.12735922",
      "price": "10147",
      "side": "sell"
    },
    {
      "id": "fb1712f2-e183-457c-b9e5-ff0d31fccd1f",
      "timestamp": 1565672192014,
      "amount": "0.08703703",
      "price": "10149",
      "side": "sell"
    },
    {
      "id": "b8cf5e20-65ca-4f45-a94c-44b7cb3952a5",
      "timestamp": 1565672192009,
      "amount": "0.0979994",
      "price": "10151",
      "side": "sell"
    },
    {
      "id": "d10cc7ec-a735-4d5c-8169-c3099f8b5003",
      "timestamp": 1565672144747,
      "amount": "0.01975188",
      "price": "10151",
      "side": "sell"
    }
  ]
  ```
  </details>

  ```python

  websocket.candles("BTC-EUR", "1h", {}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      [1548669600000, "3012.9", "3015.8", "3000", "3012.9", "8"],
      [1548669600000, "3012.9", "3015.8", "3000", "3012.9", "8"],
      [1548669600000, "3012.9", "3015.8", "3000", "3012.9", "8"],
      [1548417600000, "3124", "3125.1", "3124", "3124", "0.1"],
      [1548237600000, "3143", "3143.3", "3141.1", "3143", "60.67250851"],
  ]
  ```
  </details>

  ```python

  websocket.tickerPrice({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {"market": "EOS-EUR", "price": "2.0142"},
      {"market": "XRP-EUR", "price": "0.27848"},
      {"market": "ETH-EUR", "price": "99.877"},
      {"market": "IOST-EUR", "price": "0.005941"},
      {"market": "BCH-EUR", "price": "106.57"},
      {"market": "BTC-EUR", "price": "3008.9"},
      {"market": "STORM-EUR", "price": "0.0025672"},
      {"market": "EOS-BTC", "price": "0.00066289"},
  ]
  ```
  </details>

  ```python

  websocket.tickerBook({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "market": "ZIL-BTC",
          "bid": "0.00000082",
          "ask": "0.00000083",
          "bidSize": "13822.00651664",
          "askSize": "5743.88893286",
      },
      {
          "market": "ZIL-EUR",
          "bid": "0.0082973",
          "ask": "0.0084058",
          "bidSize": "19586.15862762",
          "askSize": "19048.86640562",
      },
      {
          "market": "ZRX-BTC",
          "bid": "0.00001625",
          "ask": "0.00001629",
          "bidSize": "823.87743487",
          "askSize": "868.23901671",
      },
      {
          "market": "ZRX-EUR",
          "bid": "0.16443",
          "ask": "0.16498",
          "bidSize": "898.35016343",
          "askSize": "419.16696625",
      },
  ]
  ```
  </details>

  ```python

  websocket.ticker24h({}, timeCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "market": "XVG-EUR",
          "open": "0.0045692",
          "high": "0.0045853",
          "low": "0.0043599",
          "last": "0.0044047",
          "volume": "594786.9689017",
          "volumeQuote": "2648.07",
          "bid": "0.0043493",
          "bidSize": "1561220.43836043",
          "ask": "0.004453",
          "askSize": "1457312.74672114",
          "timestamp": 1565684835077,
      },
      {
          "market": "ZIL-EUR",
          "open": "0.0081178",
          "high": "0.0084196",
          "low": "0.0077389",
          "last": "0.0084071",
          "volume": "950455.78568402",
          "volumeQuote": "7687.71",
          "bid": "0.008294",
          "bidSize": "19593.90088084",
          "ask": "0.0084",
          "askSize": "19048.86640562",
          "timestamp": 1565684834952,
      },
      {
          "market": "ZRX-EUR",
          "open": "0.1731",
          "high": "0.1731",
          "low": "0.16426",
          "last": "0.16477",
          "volume": "22486.29651877",
          "volumeQuote": "3727.45",
          "bid": "0.16436",
          "bidSize": "898.75082725",
          "ask": "0.16476",
          "askSize": "419.31541176",
          "timestamp": 1565684835335,
      },
  ]
  ```
  </details>


  When placing an order, make sure that the correct optional parameters are set.
  For a limit order it is required to set both the amount and price. A market
  order is valid if either amount or amountQuote has been set.
  ```python




  websocket.placeOrder(
      "BTC-EUR", "buy", "limit", {"amount": "1", "price": "3000"}, ownCallback
  )
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "orderId": "5444f908-67c4-4c5d-a138-7e834b94360e",
      "market": "BTC-EUR",
      "created": 1548671550610,
      "updated": 1548671550610,
      "status": "new",
      "side": "buy",
      "orderType": "limit",
      "amount": "1",
      "amountRemaining": "1",
      "price": "3000",
      "onHold": "3007.5",
      "onHoldCurrency": "EUR",
      "filledAmount": "0",
      "filledAmountQuote": "0",
      "feePaid": "0",
      "feeCurrency": "EUR",
      "fills": [],
      "selfTradePrevention": "decrementAndCancel",
      "visible": true,
      "timeInForce": "GTC",
      "postOnly": false,
  }
  ```
  </details>

  When updating an order make sure that at least one of the optional parameters
  has been set. Otherwise nothing can be updated.
  ```python



  websocket.updateOrder(
      "BTC-EUR", "5444f908-67c4-4c5d-a138-7e834b94360e", {"amount": "1.1"}, ownCallback
  )
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "orderId": "5444f908-67c4-4c5d-a138-7e834b94360e",
      "market": "BTC-EUR",
      "created": 1548671550610,
      "updated": 1548671831685,
      "status": "new",
      "side": "buy",
      "orderType": "limit",
      "amount": "1.1",
      "amountRemaining": "1.1",
      "price": "3000",
      "onHold": "3308.25",
      "onHoldCurrency": "EUR",
      "filledAmount": "0",
      "filledAmountQuote": "0",
      "feePaid": "0",
      "feeCurrency": "EUR",
      "fills": [],
      "selfTradePrevention": "decrementAndCancel",
      "visible": true,
      "timeInForce": "GTC",
      "postOnly": false,
  }
  ```
  </details>

  ```python
  websocket.getOrder("BTC-EUR", "5444f908-67c4-4c5d-a138-7e834b94360e", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "orderId": "5444f908-67c4-4c5d-a138-7e834b94360e",
      "market": "BTC-EUR",
      "created": 1548671550610,
      "updated": 1548671550610,
      "status": "new",
      "side": "buy",
      "orderType": "limit",
      "amount": "1",
      "amountRemaining": "1",
      "price": "3000",
      "onHold": "3007.5",
      "onHoldCurrency": "EUR",
      "filledAmount": "0",
      "filledAmountQuote": "0",
      "feePaid": "0",
      "feeCurrency": "EUR",
      "fills": [],
      "selfTradePrevention": "decrementAndCancel",
      "visible": true,
      "timeInForce": "GTC",
      "postOnly": false,
  }
  ```
  </details>

  ```python
  websocket.cancelOrder("BTC-EUR", "5986db7b-8d6e-4577-8003-22f363fb3626", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"orderId": "5986db7b-8d6e-4577-8003-22f363fb3626"}
  ```
  </details>

  Returns the same as get order, but can be used to return multiple orders at
  once.
  ```python

  websocket.getOrders("BTC-EUR", {}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "orderId": "bad72641-7755-464c-8dcb-7c1d59b142ab",
          "market": "BTC-EUR",
          "created": 1548670024870,
          "updated": 1548670024870,
          "status": "partiallyFilled",
          "side": "buy",
          "orderType": "limit",
          "amount": "1",
          "amountRemaining": "0.5",
          "price": "3000",
          "onHold": "1504.5",
          "onHoldCurrency": "EUR",
          "filledAmount": "0.5",
          "filledAmountQuote": "1500",
          "feePaid": "3",
          "feeCurrency": "EUR",
          "fills": [
              {
                  "id": "108c3633-0276-4480-a902-17a01829deae",
                  "timestamp": 1548671992530,
                  "amount": "0.5",
                  "price": "3000",
                  "taker": false,
                  "fee": "3",
                  "feeCurrency": "EUR",
                  "settled": true,
              }
          ],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
      {
          "orderId": "da1d8330-d6b7-4753-800a-01ad510a679b",
          "market": "BTC-EUR",
          "created": 1548666570234,
          "updated": 1548666570234,
          "status": "filled",
          "side": "sell",
          "orderType": "limit",
          "amount": "0.1",
          "amountRemaining": "0",
          "price": "4000",
          "onHold": "0",
          "onHoldCurrency": "BTC",
          "filledAmount": "0.1",
          "filledAmountQuote": "400",
          "feePaid": "0.8",
          "feeCurrency": "EUR",
          "fills": [
              {
                  "id": "79e4bf2f-4fac-4895-9bb2-a5c9c6e2ff3f",
                  "timestamp": 1548666712071,
                  "amount": "0.1",
                  "price": "4000",
                  "taker": false,
                  "fee": "0.8",
                  "feeCurrency": "EUR",
                  "settled": true,
              }
          ],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
  ]
  ```
  </details>

  Cancels all orders in a market. If no market is specified, all orders of an
  account will be canceled.
  ```python

  websocket.cancelOrders({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
    {
      "orderId": "4f9a809b-859f-4d8d-97b3-037113cdf2d0"
    },
    {
      "orderId": "95313ae5-ad65-4430-a0fb-63591bbc337c".
    },
    {
      "orderId": "2465c3ab-5ae2-4d4d-bec7-345f51b3494d"
    },
  ]
  ```
  </details>

  Returns all orders which are not filled or canceled.
  ```python

  websocket.ordersOpen({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "orderId": "bad72641-7755-464c-8dcb-7c1d59b142ab",
          "market": "BTC-EUR",
          "created": 1548670024870,
          "updated": 1548670024870,
          "status": "partiallyFilled",
          "side": "buy",
          "orderType": "limit",
          "amount": "1",
          "amountRemaining": "0.5",
          "price": "3000",
          "onHold": "1504.5",
          "onHoldCurrency": "EUR",
          "filledAmount": "0.5",
          "filledAmountQuote": "1500",
          "feePaid": "3",
          "feeCurrency": "EUR",
          "fills": [
              {
                  "id": "108c3633-0276-4480-a902-17a01829deae",
                  "timestamp": 1548671992530,
                  "amount": "0.5",
                  "price": "3000",
                  "taker": false,
                  "fee": "3",
                  "feeCurrency": "EUR",
                  "settled": true,
              }
          ],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
      {
          "orderId": "7586d610-2732-4ee6-8516-bed18cfc853b",
          "market": "BTC-EUR",
          "created": 1548670088749,
          "updated": 1548670088749,
          "status": "new",
          "side": "buy",
          "orderType": "limit",
          "amount": "1",
          "amountRemaining": "1",
          "price": "3000",
          "onHold": "3007.5",
          "onHoldCurrency": "EUR",
          "filledAmount": "0",
          "filledAmountQuote": "0",
          "feePaid": "0",
          "feeCurrency": "EUR",
          "fills": [],
          "selfTradePrevention": "decrementAndCancel",
          "visible": true,
          "timeInForce": "GTC",
          "postOnly": false,
      },
  ]
  ```
  </details>

  Returns all trades within a market for this account.
  ```python

  websocket.trades("BTC-EUR", {}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "id": "108c3633-0276-4480-a902-17a01829deae",
          "timestamp": 1548671992530,
          "market": "BTC-EUR",
          "side": "buy",
          "amount": "0.5",
          "price": "3000",
          "taker": false,
          "fee": "3",
          "feeCurrency": "EUR",
          "settled": true,
      },
      {
          "id": "79e4bf2f-4fac-4895-9bb2-a5c9c6e2ff3f",
          "timestamp": 1548666712071,
          "market": "BTC-EUR",
          "side": "sell",
          "amount": "0.1",
          "price": "4000",
          "taker": false,
          "fee": "0.8",
          "feeCurrency": "EUR",
          "settled": true,
      },
      {
          "id": "102486d3-5b72-4fa2-89cf-84c934edb7ae",
          "timestamp": 1548666561486,
          "market": "BTC-EUR",
          "side": "sell",
          "amount": "0.1",
          "price": "4000",
          "taker": true,
          "fee": "1",
          "feeCurrency": "EUR",
          "settled": true,
      },
  ]
  ```
  </details>

  Returns the fee tier for this account.
  ```python
  websocket.account(ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"fees": {"taker": "0.0025", "maker": "0.0015", "volume": "100.00"}}
  ```
  </details>

  Returns the balance for this account.
  ```python

  websocket.balance({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {"symbol": "EUR", "available": "2599.95", "inOrder": "2022.65"},
      {"symbol": "BTC", "available": "1.65437", "inOrder": "0.079398"},
      {"symbol": "ADA", "available": "4.8", "inOrder": "0"},
      {"symbol": "BCH", "available": "0.00952811", "inOrder": "0"},
      {"symbol": "BSV", "available": "0.00952811", "inOrder": "0"},
  ]
  ```
  </details>

  Returns the address which can be used to deposit funds.
  ```python
  websocket.depositAssets("BTC", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"address": "BitcoinAddress"}
  ```
  </details>

  Can be used to withdraw funds from Bitvavo.
  ```python

  websocket.withdrawAssets("BTC", "1", "BitcoinAddress", {}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {"success": True, "symbol": "BTC", "amount": "1"}
  ```
  </details>

  Returns the deposit history of your account.
  ```python

  websocket.depositHistory({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "timestamp": 1521550025000,
          "symbol": "EUR",
          "amount": "1",
          "fee": "0",
          "status": "completed",
          "address": "NL12RABO324234234",
      },
      {
          "timestamp": 1511873910000,
          "symbol": "BTC",
          "amount": "0.099",
          "fee": "0",
          "status": "completed",
          "txId": "0c6497e608212a516b8218674cb0ca04f65b67a00fe8bddaa1ecb03e9b029255",
      },
  ]
  ```
  </details>

  Returns the withdrawal history of an account.
  ```python

  websocket.withdrawalHistory({}, ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  [
      {
          "timestamp": 1548425559000,
          "symbol": "BTC",
          "amount": "0.09994",
          "fee": "0.00006",
          "status": "awaiting_processing",
          "address": "1CqtG5z55x7bYD5GxsAXPx59DEyujs4bjm",
      },
      {
          "timestamp": 1548409721000,
          "symbol": "EUR",
          "amount": "50",
          "fee": "0",
          "status": "completed",
          "address": "NL123BIM",
      },
      {
          "timestamp": 1537803091000,
          "symbol": "BTC",
          "amount": "0.01939",
          "fee": "0.00002",
          "status": "completed",
          "txId": "da2299c86fce67eb899aeaafbe1f81cf663a3850cf9f3337c92b2d87945532db",
          "address": "3QpyxeA7yWWsSURXEmuBBzHpxjqn7Rbyme",
      },
  ]
  ```
  </details>


  Sends an update every time the best bid, best ask or last price changed.
  ```python
  websocket.subscriptionTicker("BTC-EUR", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "event": "ticker",
      "market": "BTC-EUR",
      "bestBid": "9286.9",
      "bestBidSize": "0.10705272",
      "bestAsk": "9287.6",
      "bestAskSize": "0.10990704",
      "lastPrice": "9335",
  }
  ```
  </details>

  Updated ticker24h objects are sent on this channel once per second. A ticker24h
  object is considered updated if one of the values besides timestamp has changed.
  ```python
  websocket.subscriptionTicker24h("BTC-EUR", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "market": "BTC-EUR",
      "open": "10140",
      "high": "10216",
      "low": "10062",
      "last": "10119",
      "volume": "37.59541492",
      "volumeQuote": "381752.87",
      "bid": "10118",
      "bidSize": "0.07267404",
      "ask": "10119",
      "askSize": "0.09386124",
      "timestamp": 1565685285795,
  }
  ```
  </details>

  Sends an update whenever an event happens which is related to the account. These
  are ‘order’ events (create, update, cancel) or ‘fill’ events (a trade occurred).
  ```python
  websocket.subscriptionAccount("BTC-EUR", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  Fill:
  {
    "event": "fill",
    "timestamp": 1548674189411,
    "market": "BTC-EUR",
    "orderId": "78fef2d4-6278-4f4b-ade9-1a1c438680e5",
    "fillId": "90d49d30-9d90-427d-ab4d-35d18c3356cb",
    "side": "buy",
    "amount": "0.03322362",
    "price": "3002.4",
    "taker": true,
    "fee": "0.249403312",
    "feeCurrency": "EUR"
  }
  Order:
  {
    "event": "order",
    "orderId": "78fef2d4-6278-4f4b-ade9-1a1c438680e5",
    "market": "BTC-EUR",
    "created": 1548674189406,
    "updated": 1548674189406,
    "status": "filled",
    "side": "buy",
    "orderType": "market",
    "amountQuote": "100",
    "amountQuoteRemaining": "0.249403312",
    "onHold": "0",
    "onHoldCurrency": "EUR",
    "selfTradePrevention": "decrementAndCancel",
    "visible": false,
    "disableMarketProtection": false
  }
  ```
  </details>

  Sends an updated candle after each trade for the specified interval and market.
  ```python
  websocket.subscriptionCandles("BTC-EUR", "1h", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "event": "candle",
      "market": "BTC-EUR",
      "interval": "1h",
      "candle": [[1548676800000, "2999.3", "2999.3", "2990.5", "2999.3", "11.15058838"]],
  }
  ```
  </details>

  Sends an update whenever a trade has happened on this market. For your own
  trades, please subscribe to account.
  ```python
  websocket.subscriptionTrades("BTC-EUR", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "event": "trade",
      "timestamp": 1548677539543,
      "market": "BTC-EUR",
      "id": "d91bf798-e704-4f09-95f7-3444f8109346",
      "amount": "0.88114879",
      "price": "2992.2",
      "side": "buy",
  }
  ```
  </details>

  Sends an update whenever the order book for this specific market has changed. A
  list of tuples (\[price, amount\]) are returned, where amount ‘0’ means that
  there are no more orders at this price. If you wish to maintain your own copy of
  the order book, consider using the next function.
  ```python
  websocket.subscriptionBookUpdate("BTC-EUR", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "event": "book",
      "market": "BTC-EUR",
      "nonce": 14870,
      "bids": [["2994.3", "0"], ["2994.2", "0.00334147"]],
      "asks": [],
  }
  ```
  </details>

  This is a combination of get book per market and the book subscription which
  maintains a local copy. On every update to the order book, the entire order book
  is returned to the callback, while the book subscription will only return
  updates to the book.
  ```python
  websocket.subscriptionBook("BTC-EUR", ownCallback)
  ```
  <details>
   <summary>View Response</summary>
  ```python
  {
      "bids": [
          ["2996.7", "0.36620062"],
          ["2994.8", "0.04231826"],
          ["2994.2", "0.16617026"],
          ["2993.7", "0.23002489"],
      ],
      "asks": [
          ["2998.6", "8.64251588"],
          ["3001.2", "5.91405558"],
          ["3002.4", "3.5765691"],
          ["3003.9", "3.842524"],
      ],
      "nonce": 21919,
      "market": "BTC-EUR",
  }
  ```
  </details>


pkgId: b133fe4d46b7c9a80f925ec7f73cd915cb403443ba5924589594a7bbea27f011
name: python-bitvavo-api-upgraded
arch: src
version: 1.17.0
epoch: 0
release: 1
summary: A unit-tested fork of the Bitvavo API
url: https://pypi.org/project/bitvavo-api-upgraded/
rpm_license: ISC License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitvavo-api-upgraded-1.17.0-1.src.rpm
checksum_type: sha256
description:
  Crypto starts with Bitvavo. You use Bitvavo SDK for Python to buy, sell, and
  store over 200 digital assets on Bitvavo from inside your app.
  To trade and execute your advanced trading strategies, Bitvavo SDK for Python is
  a wrapper that enables you to easily call every endpoint in [Bitvavo
  API](https://docs.bitvavo.com/).
  - [Prerequisites](#prerequisites) - what you need to start developing with
    Bitvavo SDK for Python
  - [Get started](#get-started) - rapidly create an app and start trading with
    Bitvavo
  - [About the SDK](#about-the-sdk) - general information about Bitvavo SDK for
    Python
  - [API reference](https://docs.bitvavo.com/) - information on the specifics of
    every parameter
  This page shows you how to use Bitvavo SDK for Python with WebSockets. For REST,
  see the [REST readme](docs/rest.md).

  To start programming with Bitvavo SDK for Python you need:
  - [Python3](https://www.python.org/downloads/) installed on your development
    environment
    If you are working on macOS, ensure that you have installed SSH certificates:
    ```terminal
    open /Applications/Python\ 3.12/Install\ Certificates.command
    open /Applications/Python\ 3.12/Update\ Shell\ Profile.command
    ```
  - A Python app. Use your favorite IDE, or run from the command line
  - An [API key and
    secret](https://support.bitvavo.com/hc/en-us/articles/4405059841809)
    associated with your Bitvavo account
    You control the actions your app can do using the rights you assign to the API
    key. Possible rights are:
    - **View**: retrieve information about your balance, account, deposit and
      withdrawals
    - **Trade**: place, update, view and cancel orders
    - **Withdraw**: withdraw funds
      Best practice is to not grant this privilege, withdrawals using the API do
      not require 2FA and e-mail confirmation.

  Want to quickly make a trading app? Here you go:
  1. **Install Bitvavo SDK for Python**
      In your Python app, add [Bitvavo SDK for
      Python](https://github.com/bitvavo/python-bitvavo-api) from
      [pypi.org](https://pypi.org/project/python-bitvavo-api/):
      ```shell
      python -m pip install python_bitvavo_api
      ```
      If you installed from `test.pypi.com`, update the requests library: `pip
      install --upgrade  requests`.
  1. **Create a simple Bitvavo implementation**
      Add the following code to a new file in your app:
      ```python
      from python_bitvavo_api.bitvavo import Bitvavo
      import json
      import time
      
      
      class BitvavoImplementation:
          api_key = "<Replace with your your API key from Bitvavo Dashboard>"
          api_secret = "<Replace with your API secret from Bitvavo Dashboard>"
          bitvavo_engine = None
          bitvavo_socket = None
          
          def __init__(self):
              self.bitvavo_engine = Bitvavo({
                  'APIKEY': self.api_key,
                  'APISECRET': self.api_secret
              })
              self.bitvavo_socket = self.bitvavo_engine.newWebsocket()
              self.bitvavo_socket.setErrorCallback(self.error_callback)
          
          def error_callback(self, error):
              print("Add your error message.")
              
          
          
          
          def a_trading_strategy(self):
              self.bitvavo_socket.ticker24h({}, self.a_trading_strategy_callback)
          
          
          def a_trading_strategy_callback(self, response):
              
              for market in response:
                  match market["market"]:
                     case "ZRX-EUR":
                          print("Eureka, the latest bid for ZRX-EUR is: ", market["bid"] )
                          
                          
                          
                          
                          
                          
                          
                     case "a different market":
                          print("do something else")
                     case _:
                          print("Not this one: ", market["market"])
          def order_placed_callback(self, response):
              
              print("Order placed:", json.dumps(response, indent=2))
              
          
          
          def wait_and_close(self):
              
              
              
              
              limit = self.bitvavo_engine.getRemainingLimit()
              try:
                  while (limit > 0):
                      time.sleep(0.5)
                      limit = self.bitvavo_engine.getRemainingLimit()
              except KeyboardInterrupt:
                  self.bitvavo_socket.closeSocket()
      
      if __name__ == '__main__':
          bvavo = BitvavoImplementation()
          bvavo.a_trading_strategy()
          bvavo.wait_and_close()
      ```
  1. **Add security information**
     You must supply your security information to trade on Bitvavo and see your
     account information using the authenticate methods. Replace the values of
     `api_key` and `api_secret` with your credentials from [Bitvavo
     Dashboard](https://account.bitvavo.com/user/api).
     You can retrieve public information such as available markets, assets and
     current market without supplying your key and secret. However,
     unauthenticated calls have lower rate limits based on your IP address, and
     your account is blocked for longer if you exceed your limit.
  1. **Run your app**
      - Command line warriors: `python3 <filename>`.
      - IDE heroes: press the big green button.
  Your app connects to Bitvavo and returns a list the latest trade price for each
  market. You use this data to implement your trading logic.

  This section explains global concepts about Bitvavo SDK for Python.

  Bitvavo uses a weight based rate limiting system. Your app is limited to 1000
  weight points per IP or API key per minute. When you make a call to Bitvavo API,
  your remaining weight points are returned in the header of each REST request.
  Websocket methods do not return your returning weight points, you track your
  remaining weight points with a call to:
  ```python
  limit = bitvavo.getRemainingLimit()
  ```
  If you make more requests than permitted by the weight limit, your IP or API key
  is banned.
  The rate weighting for each endpoint is supplied in the [Bitvavo API
  documentation](https://docs.bitvavo.com/).

  For all methods, required parameters are passed as separate values, optional
  parameters are passed as a dictionary. Return parameters are in dictionary
  format: `response['<key>'] = '<value>'`. However, as a limit order requires more
  information than a market order, some optional parameters are required when you
  place an order.

  You must set your API key and secret for authenticated endpoints, public
  endpoints do not require authentication.


pkgId: 15d09936b0469d651c37bdedeaa2df40b4d560da25bd7cc1774ce8fdb5af4148
name: python-bitwarden-menu
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Dmenu/Rofi frontend for Bitwarden CLI tool
url: https://github.com/firecat53/bitwarden-menu
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitwarden-menu-0.4.4-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bitwarden-menu)
  ![PyPI](https://img.shields.io/pypi/v/bitwarden-menu)
  ![GitHub contributors](https://img.shields.io/github/contributors/firecat53/bitwarden-menu)

  Dmenu/Rofi frontend for managing Bitwarden vaults. Uses the [Bitwarden CLI][2]
  tool to interact with the Bitwarden database.

  This project is not associated with the Bitwarden project nor 8bit Solutions
  LLC.



  `pip install --user bitwarden-menu`

  Ensure `~/.local/bin` is in your `$PATH`. Run `bwm` and enter your database
  path, keyfile path, and password.

  **NOTE:** _Initial login to some servers, including vault.bitwarden.com, will
  require the `client_secret` from your account settings page. Ensure this is in
  your clipboard and ready to paste prior to first run.  Once logged in for the
  first time, you will not need this value again._

  For full installation documention see the [installation docs][docs/install.md].



  [Installation](docs/install.md) - [Configuration](docs/configure.md) - [Usage](docs/usage.md)



  1. Python 3.7+
  2. [Bitwarden CLI][2]. Ensure the `bw` command is in `$PATH`
  3. [Pynput][1] and [Xdg][6]
  4. Dmenu, [Rofi][3], [Wofi][7] or [Bemenu][4]
  5. xsel or wl-copy
  6. (optional) Pinentry.
  7. (optional) xdotool, ydotool(>= 1.0.0)/wtype (for Wayland).



  - Supports multiple [bitwarden.com](https://bitwarden.com) and self-hosted
    [Vaultwarden][5] accounts. Accounts can be switched on the fly.
  - Auto-type username and/or password on selection. Select to clipboard if
    desired (clipboard clears after 30 sec on X11 or after 1 paste on Wayland).
  - Supports login with 2FA code from Authenticator(TOTP), Email, or Yubikey.
  - Background process allows selectable time-out for locking the database.
  - Use a custom [Keepass 2.x style auto-type sequence][6].
  - Type, view or edit any field.
  - Open the URL in the default web browser.
  - Non U.S. English keyboard languages and layouts supported via xdotool or
    ydotool/wtype (for Wayland).
  - Edit notes using terminal or gui editor.
  - Add and Delete entries
  - Rename, move, delete and add folders and collections
  - Move any item to or from an organization, including support for multiple
    collections.
  - Hide selected folders from the default and 'View/Type Individual entries'
    views.
  - Configure the characters and groups of characters used during password
    generation.
  - Optional Pinentry support for secure passphrase entry.
  - Add, edit and type TOTP codes.



  - MIT



  `bwm [-h] [-v VAULT] [-l LOGIN] [-k] [-a AUTOTYPE] [-C]`

  - Run `bwm` or bind to keystroke combination.
  - Enter account URL on first run.
  - Start typing to match entries.
  - [Configure](docs/configure.md) ~/.config/bwm/config.ini as desired.
  - More detailed [usage information](docs/usage.md).
  - Screencast (Using Bemenu on Sway):

  ![Screencast](docs/short.gif)



  To run tests in a venv: `make test` (not implemented yet)



  - To install bitwarden-menu in a venv: `make`
  - Build man page from Markdown source: `make man`
  - Using `hatch`:
      - `hatch shell`: provies venv with editable installation.
      - `hatch build` && `hatch publish`: build and publish to Pypi.
  - Using `nix`:
      - `nix develop`: Provides development shell with all dependencies.
      - `make test` and `hatch build/publish` work as usual.



  - Unit tests
  - Notifications for syncing status (e.g. when a sync is complete)

  [1]: https://github.com/moses-palmer/pynput "Pynput"
  [2]: https://github.com/bitwarden/cli "Bitwarden CLI"
  [3]: https://davedavenport.github.io/rofi/ "Rofi"
  [4]: https://github.com/Cloudef/bemenu "Bemenu"
  [5]: https://github.com/dani-garcia/vaultwarden "Vaultwarden"
  [6]: https://pypi.org/project/xdg/ "Xdg"
  [7]: https://hg.sr.ht/~scoopta/wofi "Wofi"


pkgId: a4236aa3c0cf4051580aff04b563d7024af2dce54b2aee2820771aa521a2fa26
name: python-bitwarden_workflow_linter
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Custom GitHub Action Workflow Linter
url: https://github.com/bitwarden/workflow-linter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bitwarden_workflow_linter-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Bitwarden's Workflow Linter is an extensible linter to apply opinionated organization-specific
  GitHub Action standards. It was designed to be used alongside tools like
  [action-lint](https://github.com/rhysd/actionlint) and
  [yamllint](https://github.com/adrienverge/yamllint) to check for correct Action syntax and enforce
  specific YAML standards.

  To see an example of Workflow Linter in practice in GitHub Action, see the
  [composite Action](https://github.com/bitwarden/gh-actions/tree/main/lint-workflow).





  ```
  Not yet implemented
  ```



  ```
  git clone git@github.com:bitwarden/workflow-linter.git
  cd workflow-linter

  pip install -e .
  ```





  If a non-default configuration is desired (different than `src/bitwarden_workflow_linter/default_settings.yaml`), copy
  the below and create a `settings.yaml` in the directory that `bwwl` will be running from.

  ```yaml
  enabled_rules:
      - bitwarden_workflow_linter.rules.name_exists.RuleNameExists
      - bitwarden_workflow_linter.rules.name_capitalized.RuleNameCapitalized
      - bitwarden_workflow_linter.rules.pinned_job_runner.RuleJobRunnerVersionPinned
      - bitwarden_workflow_linter.rules.job_environment_prefix.RuleJobEnvironmentPrefix
      - bitwarden_workflow_linter.rules.step_pinned.RuleStepUsesPinned
      - bitwarden_workflow_linter.rules.underscore_outputs.RuleUnderscoreOutputs

  approved_actions_path: default_actions.json
  ```

  ```
  usage: bwwl [-h] [-v] {lint,actions} ...

  positional arguments:
    {lint,actions}
      lint          Verify that a GitHub Action Workflow follows all of the Rules.
      actions       Add or Update Actions in the pre-approved list.

  options:
    -h, --help      show this help message and exit
    -v, --verbose
  ```





  -   Python 3.11
  -   pipenv



  ```
  pipenv install --dev
  pipenv shell
  ```



  All built-in `src/bitwarden_workflow_linter/rules` should have 100% code coverage and we should shoot for an overall coverage of 80%+.
  We are lax on the
  [imperative shell](https://www.destroyallsoftware.com/screencasts/catalog/functional-core-imperative-shell)
  (code interacting with other systems; ie. disk, network, etc), but we strive to maintain a high coverage over the
  functional core (objects and models).

  ```
  pipenv shell
  pytest tests --cov=src
  ```



  We adhere to PEP8 and use `black` to maintain this adherence. `black` should be run on any change being merged
  to `main`.

  ```
  pipenv shell
  black .
  ```



  We loosely use [Google's Python style guide](https://google.github.io/styleguide/pyguide.html), but yield to
  `black` when there is a conflict

  ```
  pipenv shell
  pylint --rcfile pylintrc src/ tests/
  ```



  A new Rule is created by extending the Rule base class and overriding the `fn(obj: Union[Workflow, Job, Step])` method.
  Available attributes of `Workflows`, `Jobs` and `Steps` can be found in their definitons under `src/models`.

  For a simple example, we'll take a look at enforcing the existence of the `name` key in a Job. This is already done by
  default with the src.rules.name_exists.RuleNameExists, but provides a simple enough example to walk through.

  ```python
  from typing import Union, Tuple

  from ..rule import Rule
  from ..models.job import Job
  from ..models.workflow import Workflow
  from ..models.step import Step
  from ..utils import LintLevels, Settings


  class RuleJobNameExists(Rule):
      def __init__(self, settings: Settings = None) -> None:
          self.message = "name must exist"
          self.on_fail: LintLevels = LintLevels.ERROR
          self.compatibility: List[Union[Workflow, Job, Step]] = [Job]
          self.settings: Settings = settings

      def fn(self, obj: Job) -> Tuple[bool, str]:
          """<doc block goes here> """
          if obj.name is not None:
              return True, ""
          return False, self.message
  ```

  By default, a new Rule needs five things:

  -   `self.message`: The message to return to the user on a lint failure
  -   `self.on_fail`: The level of failure on a lint failure (NONE, WARNING, ERROR).
      NONE and WARNING will exit with a code of 0 (unless using `strict` mode for WARNING).
      ERROR will exit with a non-zero exit code
  -   `self.compatibility`: The list of objects this rule is compatible with. This is used to create separate instances of
      the Rule for each object in the Rules collection.
  -   `self.settings`: In general, this should default to what is shown here, but allows for overrides
  -   `self.fn`: The function doing the actual work to check the object and enforce the standard.

  `fn` can be as simple or as complex as it needs to be to run a check on a _single_ object. This linter currently does
  not support Rules that check against multiple objects at a time OR file level formatting (one empty between each step or
  two empty lines between each job)

  To activate a rule after implementing it, add it to `settings.yaml` in the project's base folder
  and `src/bitwarden_workflow_linter/default_settings.yaml` to make the rule default



  -   [ ] Add Rule to assert correct format for single line run


pkgId: baeb4be5868ff0604d770809e1b5c0beadeab73f5f5146bdbf124e8c6d4d7991
name: python-biu
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: tiny web crawler
url: https://pypi.org/project/biu/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biu-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A tiny web crawler framework


  * 请使用 Python3.10 或更高版本
  * 并发基于 Gevent，因此你必须在脚本一开始`import biu`，或者自行 monkey patch
  * 请求基于 Requests，请求与请求结果的参数与 Requests 基本兼容
  * 页面解析基于 Parsel, 因此使用方法与 Scrapy 一致
  * 基本是一个缩水版的 Scrapy，用法与之非常类似
  * 更多高级功能请面向源代码编程，自行发掘


  ```
  pip install biu
  ```


  ```python
  import biu  ## Must be the first line, because of monkey-included.


  class MySpider(biu.Project):
      def start_requests(self):
          for i in range(0, 301, 30):
              
              yield biu.Request(url="https://www.douban.com/group/explore/tech?start={}".format(i),
                                method="GET",
                                headers={"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"},
                                callback=self.parse)

      def parse(self, resp):
          
          for item in resp.xpath('//*[@id="content"]/div/div[1]/div[1]/div'):
              yield {
                  "title": item.xpath("div[2]/h3/a/text()").extract_first(),
                  "url": item.xpath("div[2]/h3/a/@href").extract_first(),
                  "abstract": item.css("p::text").extract_first()
              }
              


      def result_handler(self, rv):
          print("get result:", rv)
          

  biu.run(MySpider(concurrent=3, interval=0.2, max_retry=5))

  ```


pkgId: 63c529a184af88a6d848452565a569e269b827c7de8dce314883160fe0120709
name: python-bivalve
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A bi-directional shell-like socket protocol framework using asyncio.
url: https://github.com/lainproliant/bivalve
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bivalve-2.3.0-1.src.rpm
checksum_type: sha256
description:
  ![Bivalve Logo](bivalve-logo-big.png)

  This is a library implementing bi-directional shell sockets, a method of
  IPC where applications send and receive shell-formatted commands over
  simple TCP sockets.

  It also serves as an  example of asynchronous input handling while maintaining a
  connection with a remote service.  It shows effective methods of handling
  connections and maintaining sessions with the `asyncio` socket utilities.


pkgId: e96d4de9a05e7c9dba7ca7b455f5ce63efeb1f9f6761910c3c48a6956b280498
name: python-bivittatusDB
arch: src
version: 1.3.0.0
epoch: 0
release: 1
summary: Operator Based Relational Database Management system for python
url: https://github.com/BivittatusDB/BivittatusDB
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bivittatusDB-1.3.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="./logo.png" />
  </p>

  [![Static Badge](https://img.shields.io/badge/Version-View-%20green)](./version.txt "1.3.0.0")
  [![Static Badge](https://img.shields.io/badge/PIP%20-%20View-blue)](https://pypi.org/project/bivittatusDB/)
  ![Static Badge](https://img.shields.io/badge/MajorBuild-1.3.0.0-%20green)
  ![Static Badge](https://img.shields.io/badge/Language%20-%20Python%20(3.x)-blue)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=HarbingerOfFire_bivittatusDB&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=HarbingerOfFire_bivittatusDB)




  This is a Python-based relational database management system (RDBMS) designed from scratch with operator-based functionalities. It's a standalone system not compatible with SQL or NoSQL databases, aiming to provide a simple yet functional database management solution.


  - **Operator-based operations**: The database operates using operators such as `+`, `-`, and `==` to manipulate data.
  - **Relational Structure**: Organizes data in tables with rows and columns, following a relational database model.
  - **Basic CRUD Operations**: Supports basic Create, Read, Update, and Delete operations.
  - **Indexing**: Efficient data retrieval with indexing mechanisms.
  - **Transaction Management**: Implements transaction management to ensure data consistency.
  - **Security**: All databases are asymmetrically encrypted with a user defined password for each database.


  Installation is now available through pip, via the latest release. To get the latest fix (with beta features) use
  ```bash
  pip install bivittatusDB
  ```
  The last build is unavailable via pip at this time. Based on the [release schedule](https://github.com/HarbingerOfFire/bivittatusDB/wiki/dbed-0001), release 2.0.0.0 should be released 08/01/2025. The closest working version of build 1.0.0.0 available on PyPi is v1.0.0.1
  ```bash
  pip install bivittatusDB==1.0.0.1
  ```


  See the examples directory and [wiki](https://github.com/HarbingerOfFire/PYDB/wiki) for examples off different operations.


  1. clone the repo and cd into the BivitattusDB directroy
  2. Import bivittatusDB into your python file/interpreter.
  3. Follow the information from the [wiki](https://github.com/HarbingerOfFire/PYDB/wiki) for more info on specific usage


  The databases are saved in hybrid-asymmetrically encrypted and therefore need encryption handlers, as seen in the [`requirements.txt`](.github/requirements.txt) file.
  ```bash
  pip install -r .github/requirements.txt
  ```


  Contributions are welcome! If you'd like to contribute to the project, please fork the repository and submit a pull request with your changes.See [Contributing](.github/CONTRIBUTING.md) & [Code of Cunduct](.github/CODE_OF_CONDUCT.md)


  This project is licensed under the [MIT License](.github/LICENSE).

  This README.md file provides an overview of the operator-based relational database management system implemented in Python, detailing its current features, future plans, usage instructions, dependencies, and contribution guidelines. Additionally, it outlines the licensing information for the project.


  Due to recent updates, no issues are known at this time. All example files are acting as expected. We are accepting issues if you find anything that we have missed.


pkgId: d3f943d86cee0ed908812097e2cb1be375d06c588e98f2c3526511c4e601a990
name: python-biweeklybudget
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Responsive Flask/SQLAlchemy personal finance app, specifically for biweekly budgeting.
url: https://github.com/jantman/biweeklybudget
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biweeklybudget-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Responsive Flask/SQLAlchemy personal finance app, specifically for biweekly budgeting.
  **For full documentation**, see `http://biweeklybudget.readthedocs.io/en/latest/ <http://biweeklybudget.readthedocs.io/en/latest/>`_
  **For screenshots**, see `<http://biweeklybudget.readthedocs.io/en/latest/screenshots.html>`_


pkgId: 4275f060a5ae5d5ba1ae89580a4753e527173c6d7806acccc5fc0a9f84e40f1a
name: python-biwrap
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Yet simple util to make wrapper with optional arguments
url: https://github.com/ferrine/biwrap
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-biwrap-0.1.6-1.src.rpm
checksum_type: sha256
description:
  The above example shows redundancy in
  -   decorator definition has double nesting (double ``def``)
  -   usage requires trailing parenthesis ``@register()`` even in case we do not use optional argument
  More readable code should avoid these two points and look like:
      def register(fn, alias=None):
      @register
      def f1(a):
          return a
      @register(alias='fn3')  # <- (1)
      def f2(a):
          return a
  Naive implementation of the above API won't work. Line marked above as ``(1)`` will fail as first argument ``fn`` is not passed. But we want the output to be the same.
  Better solution
  ***************
      import biwrap
      @biwrap.biwrap
      def register(fn, alias=None):
          if fn.__name__ not in register.storage:
              register.storage[fn.__name__] = fn
          elif register.storage[fn.__name__] is not fn:
              raise KeyError('{} is already in storage'.format(fn.__name__))
          if alias is not None and alias not in register.storage:
              register.storage[alias] = fn
          elif alias is not None:
              raise KeyError('{} is already in storage'.format(alias))
          return fn
      register.storage = {}
      @register
      def f1(a):
          return a
      print(register.storage)
      
      @register(alias='fn3')
      def f2(a):
          return a
      print(register.storage)
      
  Functionality Overview

  Some corner cases may exist and custom coding can create a boilerplate for each usecase (see this `SO thread <https://stackoverflow.com/questions/3888158/making-decorators-with-optional-arguments>`__). This package takes the best and implements yet simple but generic solution to resolve them all(?).
  Setup
  *****
  Let's take a simple wrapper as an example. It will print ``hi`` or ``bye`` depending on parametrization, default is ``hi``.
      import biwrap
      @biwrap.biwrap
      def hiwrap(fn, hi=True):
          def new(*args, **kwargs):
              if hi:
                  print('hi')
              else:
                  print('bye')
              return fn(*args, **kwargs)
          return new
  Cases
  *****


pkgId: d467286a7c726e023ff6609764ddcbed20b61fae2bc52f650fad2bd0e4871041
name: python-bizcal
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Pythonic Business (Trading) Calendar.
url: https://github.com/sunyj/bizcal
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bizcal-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **Bizcal** is a simple business calendar package with three unique features:

  - Compatibility: `bizcal.Date` is a drop-in replacement for `datetime.date`.
  - Pythonic: intuitive syntax.
  - Holiday-aware: not just *when* not trading, but also *why*.

  Bizcal is [listed on PyPI](https://pypi.org/project/bizcal/).



  Bizcal abstracts dates with `Date` class, a direct subclass of the standard
  `datetime.date`, allowing it to seamlessly integrate into legacy codebases as
  a drop-in replacement for `datetime.date`.

  Additionally, `Date` includes several convenient methods and properties designed to simplify your code.



  Code snippets speak for themselves.  Check more in [unit tests](./test/basic.py).

  ```python
  from bizcal import Calendar

  cne = Calendar([
      '2023: 0101-2, 0121-29, 0405, 0429-0503, 0622-25, 0929-1008',
      '2024: 0101, 0209-18, 0404-7, 0501-5, 0608-10, 0914-17, 1001-7',
  ])

  day = cne('20240210')


  while not day:
      day = day >> 1
  prev_trading_day = day << 1
  next_trading_day = day >> 1


  yesterday = day - 1
  tomorrow = day + 1


  period = cne[20240101, 20240131]
  print(len(period), 'trading days')


  print(sum(1 for d in cne['*'].days if d.open), 'trading days')


  for day in period:
      print(f'{day} is a trading day')


  for day in period.days:
      flag = day and 'trading' or (day.holiday and 'holiday' or 'weekend')
      print(f'{day} is {flag}')
  ```



  Certain exchanges, like [SHFE](https://tsite.shfe.com.cn/eng/) and [DCE](http://www.dce.com.cn/DCE/), adjust their trading hours based on holiday
  schedules. Bizcal not only identifies business (open) and non-business
  (closed) days but also specifies if a non-business day is a holiday.





  ```python
  from bizcal import Calendar
  cal = Calendar('/path/to/calendar.file')
  cal = Calendar([
      '2023: 0101-2, 0121-29, 0405, 0429-0503, 0622-25, 0929-1008',
      '2024: 0101, 0209-18, 0404-7, 0501-5, 0608-10, 0914-17, 1001-7',
  ])
  ```

  The `Calendar(spec)` constructor accepts `spec` as either a string or a list
  of strings.

  - If `spec` is a string, it is treated as a path to a calendar definition
    file. Each line in the file defines the holidays (and potentially weekends)
    for a specific year.
  - If `spec` is a list of strings, each string represents a line of calendar
    definitions for one year.
  - The year line format is `YYYY: holidays, holidays, ...`, where `holidays`
    are specified as date ranges in the format `MMDD`, `MMDD-DD`, or
    `MMDD-MMDD`.



  `Date` objects can only be created from a `Calendar` object using call
  syntax. Multiple input formats are supported.

  ```python
  cal = Calendar([...])
  day = cal(20240501)     # integer
  day = cal('20240501')   # YYYYMMDD (string)
  day = cal('2024-05-01') # YYYY-MM-DD
  day = cal('2024.05.01') # YYYY.MM.DD
  day = cal(2024, 5, 1)   # year, month, day
  day = cal((2024, 5, 1)) # tuple
  day = cal([2024, 5, 1]) # list
  day = cal(date)         # date or even Date object
  day = cal([2025, 1, 1]) # error, as date is out of calendar scope
  ```



  A `Date` object can be shifted both as calendar days and business days. The
  `+` and `-` operators shift the date as calendar days, while the `>>` and `<<`
  operators shift the date as business days.

  ```python
  cal = Calendar([...])
  day = cal(20240501)

  day + 10   # 2024-05-11
  day - 1    # 2024-04-30

  day >> 10  # 2024-05-17
  day << 10  # 2024-04-17
  ```



  `Date` is a subclass of `datetime.date`, so all `date` methods are supported.



  - `Date.open`: Indicates if it is a business day (boolean).
    - `Date.__bool__()`: Boolean operator, returns if it is a business day.
  - `Date.holiday`: Indicates if it is a holiday (boolean).
  - `Date.num`: Returns the date as an `YYYYMMDD` integer.
  - `Date.str`: Returns the date as a `"YYYYMMDD"` string.
  - `Date.eom`: Indicates if it is the end of the month (boolean).



  - `Date.spec(sep='')`: Returns the date as a `YYYY{sep}MM{sep}DD` string.
  - `Date.shift(days)`: Performs an explicit business day shift.



  A period of dates can be defined using the indexing (brackets) syntax.

  ```python
  cal = Calendar([...])
  period = cal[20240101, 20240131]
  jan = cal['20240101-31']
  q1 = cal['202401-3']
  h1 = cal['202401-06']
  years = cal['2023-4']

  period = cal[cal('20240101'), cal(2024, 1, 1) + 30]

  print(len(jan))  # count trading days
  print(jan.spec)  # period spec string
  ```

  The length of a period (`len(period)`) is the number of business days in that
  period.



  The primary use case of a period is date iteration. Two generator properties,
  `bizdays` and `days`, are implemented for business day and calendar day
  iteration, respectively. The default iteration method (`__iter__`) is for
  business days.

  ```python

  for day in cal['202401']:
      print(f'{day} is a trading day')


  for day in cal['20240215-20'].days:
      flag = day and 'trading' or (day.holiday and 'holiday' or 'weekend')
      print(f'{day} is {flag}')
  ```


  Static method `Calendar.span(spec: str)` parses a string spec into
  `(beg, end)` tuple of dates.  `datetime.date` objects are returned.

  ```python
  from bizcal import Calendar

  beg, end = Calendar.span('202402')
  ```


pkgId: e320db058963acc8d2f9f40ceed99273ccb3fd96763000d9b7f0b80444474efb
name: python-bizdays
arch: src
version: 1.0.15
epoch: 0
release: 1
summary: Functions to handle business days calculations
url: https://pypi.org/project/bizdays/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bizdays-1.0.15-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://img.shields.io/pypi/dm/bizdays.svg)](https://pypi.python.org/pypi/bizdays/)
  [![Latest Version](https://img.shields.io/pypi/v/bizdays.svg)](https://pypi.python.org/pypi/bizdays/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/bizdays.svg)](https://pypi.python.org/pypi/bizdays/)



  In several countries and markets, the accountability of the price of a financial
  instrument, mainly bonds and derivatives, involves the use of different rules to
  compute the way the days go by.
  In Brazil, several financial instruments pay interest according to the business
  days along their life cycle.
  So, having a way to compute the number of business days between 2 dates is
  fairly useful to price financial instruments.
  **bizdays** was created to make it easier.

  **bizdays** computes business days between two dates based on the definition of
  nonworking days (usually holidays and weekends).
  It also computes other collateral effects like adjust dates for the next or
  previous business day, check whether a date is a business day, create sequences
  of business days, and much more.

  Several financial libraries compute the holidays, giving no option to users set
  it by their own.
  Furtherly, the financial calendar is usually a small feature of a huge library,
  as quantlib, for example, and some users, including myself, don't want to put a
  hand in such a huge library only to use the financial calendar.

  **bizdays** is a pure Python module without strong dependencies,
  what makes it appropriated for small projects.


pkgId: d409a34c149aa2a10c98140c75ddc9b5f7b75326739a58e25dae1ab8e8f5b228
name: python-bizerror
arch: src
version: 0.4.11
epoch: 0
release: 1
summary: Collections of common business errors.
url: https://pypi.org/project/bizerror/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bizerror-0.4.11-1.src.rpm
checksum_type: sha256
description:
  Collections of common business errors.



  ```shell
  pip install bizerror
  ```



  - bizerror-generator



  - OK
  - BizError
  - SysError
      - UndefinedError
      - DatabaseError
      - CacheError
      - MessageQueueError
      - AnotherServiceError
  - HttpError
      - RequestExpired
      - NotSupportedHttpMethod
      - BadResponseContent
      - NoMatchingRouteFound
      - ReqeustForbidden
      - NoUpstreamServerAvailabe
  - ConfigError
      - MissingConfigItem
  - DataError
      - TargetNotFound
  - AuthError
      - AccountLockedError
      - AccountTemporaryLockedError
      - UserPasswordError
      - AppAuthFailed
      - TsExpiredError
      - AccountDisabledError
      - AccountStatusError
      - AccountRemovedError
      - LoginRequired
      - AccessDenied
      - UserDoesNotExist
      - BadUserToken
      - ReqidDuplicateError
  - TypeError
      - ParseJsonError
  - ParamError
      - MissingParameter
      - BadParameter
      - BadParameterType
      - StringTooShort
      - StringTooLong
      - MissingField
      - WrongFieldType
      - WrongParameterType
      - ValueExceedsMaxLimit
      - ValueLessThanMinLimit
  - FormError
      - CaptchaOnlyAllowedOnce
      - CaptchaValidateFailed
      - RepeatedlySubmitForm
      - CaptchaRequired
  - LogicError
  - CastFailedError
      - CastToIntegerFailed
      - CastToFloatFailed
      - CastToNumbericFailed
      - CastToBooleanFailed
      - CastToStringFailed
      - NotSupportedTypeToCast
  - PermissionError
      - NoPermissionError
      - NoReadPermissionError
      - NoWritePermissionError
      - NoDeletePermissionError
      - NoAccessPermissionError
      - NoPermissionToCleanCacheError





  - Add BizError base class.
  - Add some common errors.



  - Add auto generate mechanism.
  - Add language support.



  - Fix get_error_message always use default language problem.
  - Add BizError.MESSAGE classproperty.



  - Add NotSupportedTypeToCast error.



  - Add message parameters support.
  - Add exception classes.
  - Add class generator and tempalte maker.



  - Fix xlsxhelper dependencies problem.



  - Get error message by error class name, so that we can provide error message override function.



  - Add UserDoesNotExist.
  - Add BadUserToken.



  - Fix unicode encode/decode problems.
  - Support python3 only.



  - Add StringTooShort and StringTooLong.
  - Fix bizerror.BizError(another_bizerror) problem.



  - Add BadResponseContent.



  - Add BizError.update.
  - Add CastFailedError.



  - bizerror.BizError add init by a dict supporting.
  - Add bizerror.PermissionError(s).



  - Fix unicode problems for old python.
  - Unittest all passed.



  - Doc update.


pkgId: 9de5c7feae0be2794fff09bce2c1d45f54f2051e94ba62cb57263ecddd17c720
name: python-bizfylabs
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A large language model module named Yukti by Bizfy Labs
url: https://github.com/bizfylabs/bizfylabs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bizfylabs-0.1.2-1.src.rpm
checksum_type: sha256
description:
  BizfyLabs is a Python module that provides a large language model named Yukti. Yukti is a general-purpose instruction model developed by Bizfy Labs.



  You can install the bizfylabs module using pip:

  ```bash
  pip install bizfylabs


pkgId: 1b026cd9ae7e7a58907646edfe72b79367e0040d1eadc72d12b0adaf82a63756
name: python-bizlogic
arch: src
version: 0.2.20
epoch: 0
release: 1
summary: web3 lending platform business logic
url: https://pypi.org/project/bizlogic/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bizlogic-0.2.20-1.src.rpm
checksum_type: sha256
description:
  Some nanoswap business logic

  ![](https://img.shields.io/readthedocs/ipfsclient?label=readthedocs)
  ![](https://img.shields.io/github/actions/workflow/status/nanoswap/ipfsclient/test.yml?label=tests)
  ![](https://img.shields.io/snyk/vulnerabilities/github/nanoswap/ipfsclient)
  ![](https://img.shields.io/pypi/pyversions/ipfsclient)

  - [Installation](#installation)
  - [Documentation](#documentation)
    * [Build docs locally](#build-docs-locally)
  - [Tests](#tests)
    * [Before running tests:](#before-running-tests-)
      + [Regenerate pb2.py files](#regenerate-pb2py-files)
      + [Ipfs setup](#ipfs-setup)
      + [Run the ipfs daemon](#run-the-ipfs-daemon)
  - [IPFS troubleshooting](#ipfs-troubleshooting)



  ```
  pip install bizlogic
  ```



  https://bizlogic.readthedocs.io/


  `mkdocs serve`


  To only run tests: `pytest --cov=bizlogic --log-cli-level=debug`
  To only run lints: `flake8 bizlogic --docstring-convention google --ignore=D100,D104 --exclude=loan_pb2.py,vouch_pb2.py,loan_application_pb2.py`
  To run all checks: `nox`




  ```
  protoc --python_out=bizlogic/protoc --proto_path=protobuf protobuf/*.proto
  ```


  https://docs.ipfs.tech/install/


  ```
  ipfs daemon --api /ip4/0.0.0.0/tcp/5001
  ```
  Check the status of your node at:
    - http://localhost:5001/webui
    - https://webui.ipfs.io/#/status




  Set the log level, send the logs to a file, and search the file for relevant messages
  ```
  export IPFS_LOGGING=<debug|info|error>
  ipfs daemon --debug 2>&1 | tee ipfs.log
  cat ipfs.log | grep test_directory
  ```

  If you find something important, you can show the first few lines around that message
  ```
  grep -C 10 '2023-04-13T17:31:49.712-0400' ipfs.log
  ```

  Here is an example of an error message in these logs:
  ```
  2023-04-13T17:31:49.712-0400	DEBUG	cmds/http	http/handler.go:90	incoming API request: /files/mkdir?arg=test_directory
  2023-04-13T17:31:49.712-0400	DEBUG	cmds	go-ipfs-cmds@v0.8.2/command.go:161	error occured in call, closing with error: paths must start with a leading slash
  ```


pkgId: 78e3a3c82f09782a0b0e579f75820f9c6258a20e062e085d7a94f7b67f18e985
name: python-bizon
arch: src
version: 0.0.11
epoch: 0
release: 1
url: https://pypi.org/project/bizon/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bizon-0.0.11-1.src.rpm
checksum_type: sha256
summary:
  Extract and load your data reliably from API Clients with native fault-tolerant and checkpointing mechanism.

description:
  Extract and load your largest data streams with a framework you can trust for billion records.


  - **Natively fault-tolerant**: Bizon uses a checkpointing mechanism to keep track of the progress and recover from the last checkpoint.
  - **High throughput**: Bizon is designed to handle high throughput and can process billions of records.
  - **Queue system agnostic**: Bizon is agnostic of the queuing system, you can use any queuing system among Python Queue, RabbitMQ, Kafka or Redpanda. Thanks to the `bizon.engine.queue.Queue` interface, adapters can be written for any queuing system.
  - **Pipeline metrics**: Bizon provides exhaustive pipeline metrics and implement OpenTelemetry for tracing. You can monitor:
      - ETAs for completion
      - Number of records processed
      - Completion percentage
      - Latency Source <> Destination
  - **Lightweight & lean**: Bizon is lightweight, minimal codebase and only uses few dependencies:
      - `requests` for HTTP requests
      - `pyyaml` for configuration
      - `sqlalchemy` for database / warehouse connections
      - `pyarrow` for Parquet file format


  ```bash
  pip install bizon
  ```




  ```bash
  bizon source list
  bizon stream list <source_name>
  ```



  Create a file named `config.yml` in your working directory with the following content:

  ```yaml
  name: demo-creatures-pipeline

  source:
    source_name: dummy
    stream_name: creatures
    authentication:
      type: api_key
      params:
        token: dummy_key

  destination:
    name: logger
    config:
      dummy: dummy
  ```

  Run the pipeline with the following command:

  ```bash
  bizon run config.yml
  ```


  Backend is the interface used by Bizon to store its state. It can be configured in the `backend` section of the configuration file. The following backends are supported:
  - `sqlite`: In-memory SQLite database, useful for testing and development.
  - `biguquery`: Google BigQuery backend, perfect for light setup & production.
  - `postgres`: PostgreSQL backend, for production use and frequent cursor updates.



  Queue is the interface used by Bizon to exchange data between `Source` and `Destination`. It can be configured in the `queue` section of the configuration file. The following queues are supported:
  - `python_queue`: Python Queue, useful for testing and development.
  - `rabbitmq`: RabbitMQ, for production use and high throughput.
  - `kafka`: Apache Kafka, for production use and high throughput and strong persistence.





  Queue configuration can be set to `python_queue` and backend configuration to `sqlite`.
  This will allow you to test the pipeline without any external dependencies.




  To test the pipeline with Kafka, you can use `docker compose` to setup Kafka or Redpanda locally.

  **Kafka**
  ```bash
  docker compose --file ./scripts/kafka-compose.yml up # Kafka
  docker compose --file ./scripts/redpanda-compose.yml up # Redpanda
  ```

  In your YAML configuration, set the `queue` configuration to Kafka under `engine`:
  ```yaml
  engine:
    queue:
      type: kafka
      config:
        queue: bootstrap_server: localhost:9092 # Kafka:9092 & Redpanda: 19092
  ```

  **RabbitMQ**
  ```bash
  docker compose --file ./scripts/rabbitmq-compose.yml up
  ```

  In your YAML configuration, set the `queue` configuration to Kafka under `engine`:

  ```yaml
  engine:
    queue:
      type: rabbitmq
      config:
        queue:
          host: localhost
          queue_name: bizon
  ```


pkgId: 448bb5115df32ea7ae1fd5a21b977233d505d6380716b4ba36163dd0e98f66b4
name: python-bjarkan-sdk
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: SDK for Bjarkan cryptocurrency trading system
url: https://pypi.org/project/bjarkan-sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bjarkan-sdk-4.0.1-1.src.rpm
checksum_type: sha256
description:
  A powerful cryptocurrency trading SDK with smart order routing capabilities and real-time market data aggregation.



  - Real-time market data aggregation from multiple exchanges
  - Fee-aware orderbook processing
  - VWAP calculations
  - Smart order routing and execution
  - Trade monitoring and filtering
  - Unified API interface for all exchanges
  - Comprehensive error handling
  - Sandbox mode support



  ```bash
  pip install bjarkan-sdk
  ```



  ```python
  import asyncio
  from bjarkan import BjarkanSDK, OrderConfig, APIConfig

  async def main():
      
      sdk = BjarkanSDK()

      
      await sdk.set_config(
          type="orderbook",
          aggregated=True,
          exchanges=["binance", "okx"],
          symbols=["BTC/USDT"],
          depth=10,
          fees_bps={
              "binance": 10,
              "okx": 8
          }
      )

      
      await sdk.start_stream(stream_type="orderbook")

      
      orderbook = await sdk.get_latest_data("orderbook")
      print(orderbook)

      
      api_configs = [
          APIConfig(
              exchange="binance",
              api_key="your_api_key",
              secret="your_secret"
          )
      ]

      order = OrderConfig(
          side="buy",
          type="limit",
          time_in_force="gtc",
          amount=0.01,
          price=50000.0
      )

      result = await sdk.execute_order(order, api_configs)
      print(result)

      
      await sdk.close()

  if __name__ == "__main__":
      asyncio.run(main())
  ```



  For more advanced features like VWAP calculations and trade monitoring, check the examples directory.



  ```python

  await sdk.set_config(
      type="orderbook",
      aggregated=True,
      exchanges=["binance", "okx", "kraken"],
      symbols=["BTC/USDT", "ETH/USDT"],
      depth=20,
      fees_bps={
          "binance": 10,
          "okx": {"BTC/USDT": 8, "ETH/USDT": 8},
          "kraken": 10
      },
      weighting={  # Enable VWAP
          "BTC/USDT": {"USDT": 20000},
          "ETH/USDT": {"USDT": 10000}
      }
  )


  await sdk.set_config(
      type="trades",
      exchanges=["binance", "okx", "kraken"],
      symbols=["BTC/USDT", "ETH/USDT"],
      size={  # Minimum trade size filter
          "BTC/USDT": {"BTC": 0.001},
          "ETH/USDT": {"ETH": 0.01}
      }
  )
  ```



  ```python

  await sdk.start_stream("orderbook")
  await sdk.start_stream("trades")


  orderbook_data = await sdk.get_latest_data("orderbook")
  trades_data = await sdk.get_latest_data("trades")


  await sdk.stop_stream("orderbook")
  await sdk.stop_stream("trades")
  ```



  1. Clone the repository:
  ```bash
  git clone https://github.com/yourusername/bjarkan-sdk.git
  cd bjarkan-sdk
  ```

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

  3. Install development dependencies:
  ```bash
  ./run.sh env_setup.sh --all
  ```



  Run the test suite:
  ```bash
  pytest tests/
  ```

  Run with coverage:
  ```bash
  pytest tests/ --cov=bjarkan --cov-report=term-missing
  ```



  1. Update version number:
  ```bash
  python bump_version.py patch  # or minor/major
  ```

  2. Deploy to PyPI:
  ```bash
  ./deploy.sh
  ```



  Create a `.env` file in your project root:

  ```env

  BINANCE_API_KEY=your_api_key
  BINANCE_SECRET=your_secret
  OKX_API_KEY=your_api_key
  OKX_SECRET=your_secret
  OKX_PASSWORD=your_password


  BETTERSTACK_TOKEN=your_token
  ```



  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/amazing-feature`)
  3. Commit your changes (`git commit -m 'Add some amazing feature'`)
  4. Push to the branch (`git push origin feature/amazing-feature`)
  5. Open a Pull Request



  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 65ce1b4b7c6bdd3b783f6237a730593265a98c4e3bbb9fe0686baebb6894847f
name: python-bk-audit
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Bk Audit SDK
url: https://bk.tencent.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bk-audit-1.2.2-1.src.rpm
checksum_type: sha256
description:
  ![logo.png](https://github.com/TencentBlueKing/bk-audit-python-sdk/blob/master/assests/logo.png)

  [![license](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/TencentBlueKing/bk-audit-python-sdk/blob/master/LICENSE.txt)
  [![Release Version](https://img.shields.io/badge/release-1.2.2-brightgreen.svg)](https://github.com/TencentBlueKing/bk-audit-python-sdk/releases)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/TencentBlueKing/bk-audit-python-sdk/pulls)
  [![codecov](https://codecov.io/github/TencentBlueKing/bk-audit-python-sdk/branch/master/graph/badge.svg?token=CUG20ZMOVQ)](https://codecov.io/github/TencentBlueKing/bk-audit-python-sdk)
  [![Test](https://github.com/TencentBlueKing/bk-audit-python-sdk/actions/workflows/unittest_py3.yml/badge.svg)](https://github.com/TencentBlueKing/bk-audit-python-sdk/actions/workflows/unittest_py3.yml)

  [(English Documents Available)](https://github.com/TencentBlueKing/bk-audit-python-sdk/blob/master/readme_en.md)



  bk-audit-python-sdk 是蓝鲸审计中心 (BK-AUDIT) 提供的用于快速接入审计体系的 Python SDK



  - [Basic] 兼容 Python2/Python3
  - [Audit] 支持自定义审计事件处理，将非标准字段格式化为审计事件
  - [Audit] 支持自定义审计事件输出，内置审计事件输出到日志文件或通过 OT 上报
  - [Contrib] Django Support, 集成了 Django 专用事件处理，通过注入 Request 对象简化审计事件上报
  - [Contrib] OpenTelemetry Support, 集成 OT Log 上报模块，直接上报到 OT Collector





  ```bash
  $ pip install bk-audit
  ```



  - [使用文档](https://github.com/TencentBlueKing/bk-audit-python-sdk/blob/master/docs/usage.md)



  - [版本日志](https://github.com/TencentBlueKing/bk-audit-python-sdk/blob/master/release.md)



  - [蓝鲸论坛](https://bk.tencent.com/s-mart/community)
  - [蓝鲸 DevOps 在线视频教程](https://bk.tencent.com/s-mart/video/)
  - [蓝鲸社区版交流群](https://jq.qq.com/?_wv=1027&k=5zk8F7G)



  - [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-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)是一套运维脚本管理系统，具备海量任务并发处理能力。



  如果你有好的意见或建议，欢迎给我们提 Issues 或 Pull Requests，为蓝鲸开源社区贡献力量。
  [腾讯开源激励计划](https://opensource.tencent.com/contribution) 鼓励开发者的参与和贡献，期待你的加入。



  基于 MIT 协议， 详细请参考 [LICENSE](https://github.com/TencentBlueKing/bk-audit-python-sdk/blob/master/License.txt)


pkgId: 82350e1867447b8f4cd08234426ad1b75a0f0886bdd8d4f865146ff88daeb5e9
name: python-bk-bscp
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: The Python SDK for blueking bscp project.
url: https://pypi.org/project/bk-bscp/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bk-bscp-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)]()

  [EnglishDocs](./readme_en.md)



  bscp-python-sdk 是蓝鲸 BSCP 项目的 Python SDK，它能帮助你轻松访问项目保存在 BSCP 上的配置内容。



  - kv 配置拉取
  - kv 配置 watch





  ```bash
  python -m pip install bk-bscp
  ```

  注: 只支持 `Python 3.8+` 版本



  使用 `BscpClient` 来完成主要操作，其支持两种不同的调用风格。

  普通风格：

  ```python
  from bk_bscp.client import BscpClient

  client = BscpClient(server_addrs, token, biz_id)
  try:
      pair = client.get("app1", "key1")
  finally:
      client.close()
  ```

  - 普通风格要求你手动管理连接，适合复用长连接，在需要完成大量操作时使用

  上下文管理器风格：

  ```python
  from bk_bscp.client import BscpClient

  with BscpClient(server_addrs, token, biz_id) as client:
      pair = client.get("app1", "key1")
  ```

  - 在这种风格下，client 的连接会自动关闭，适合短连接，操作次数不多时的场景



  更多示例代码请参考 examples/ 目录。



  安装环境

  ```bash

  uv python install {version}


  uv venv -p {path}/python


  uv sync --frozen
  ```

  执行单元测试：

  ```bash
  uv run pytest -s tests/
  ```

  一些相关的环境变量配置项：

  ```bash

  BSCP_LOG_LEVEL=DEBUG
  ```



  为了更好地测试 SDK 的功能，本项目编写了一些会连接真实 BSCP 服务器的集成测试用例。这些测试默认处于未启用状态，你可以配置以下环境变量来启用：

  ```bash
  BSCP_SERVER_ADDRS="your-bscp.example.com:9090"
  BSCP_TOKEN="your_token"
  BSCP_BIZ_ID="1"


  BSCP_EXISTENT_APP_KEY="your_app,your_key"
  ```



  在项目的 `bk_bscp/grpc_lib` 目录里，存放着由 grpc 相关工具链自动生成的 Python 源码文件。需注意的是，这些源码所依赖的原始 proto 定义文件，并未保存在本 SDK 项目中，而是存放于 bscp 主项目里。当你需要更新这批文件时，请先将 bscp 项目克隆到本地，切换到项目根目录中，执行以下命令：

  ```bash
  find ./pkg/protocol/core ./pkg/protocol/feed-server -name "*.proto" | \
      xargs python -m grpc_tools.protoc -I. -I ./pkg/thirdparty/protobuf/ --python_out=. --pyi_out=. --grpc_python_out=.
  ```

  然后，回到本 SDK 项目的 scripts/ 子目录，执行以下脚本完成同步：

  ```bash

  bash sync_grpc_generated.sh {bscp_project_path}
  ```



  - [蓝鲸论坛](https://bk.tencent.com/s-mart/community)
  - [蓝鲸 DevOps 在线视频教程](https://bk.tencent.com/s-mart/video/)
  - 联系我们，技术交流QQ群：

  <img src="https://github.com/Tencent/bk-PaaS/raw/master/docs/resource/img/bk_qq_group.png" width="250" hegiht="250" align=center />



  - [BK-CI](https://github.com/Tencent/bk-ci)：蓝鲸持续集成平台是一个开源的持续集成和持续交付系统，可以轻松将你的研发流程呈现到你面前。
  - [BK-BCS](https://github.com/Tencent/bk-bcs)：蓝鲸容器管理平台是以容器技术为基础，为微服务业务提供编排管理的基础服务平台。
  - [BK-PaaS](https://github.com/Tencent/bk-PaaS)：蓝鲸PaaS平台是一个开放式的开发平台，让开发者可以方便快捷地创建、开发、部署和管理SaaS应用。
  - [BK-SOPS](https://github.com/Tencent/bk-sops)：标准运维（SOPS）是通过可视化的图形界面进行任务流程编排和执行的系统，是蓝鲸体系中一款轻量级的调度编排类SaaS产品。
  - [BK-CMDB](https://github.com/Tencent/bk-cmdb)：蓝鲸配置平台是一个面向资产及应用的企业级配置管理平台。



  如果你有好的意见或建议，欢迎给我们提 Issues 或 Pull Requests，为蓝鲸开源社区贡献力量。



  bscp-python-sdk 是基于MIT协议， 详细请参考[LICENSE](./LICENSE.txt)。

rpm_license:
  TencentBlueKing is pleased to support the open source community by making 蓝鲸智云 - 蓝鲸智云容器管理平台(Blueking Container Service) available. Copyright (C)  2021 THL A29 Limited, a Tencent company. All rights reserved. Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://opensource.org/licenses/MIT 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. We undertake not to change the open source license (MIT license) applicable to the current version of the project delivered to anyone in the future.


pkgId: 3c8893b85f4f43fd78420d354d504732f27552039d1fc16e1a317952b5a59328
name: python-bk-crypto-python-sdk
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://pypi.org/project/bk-crypto-python-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bk-crypto-python-sdk-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  bk-crypto-python-sdk is a lightweight cryptography toolkit for Python applications based on Cryptodome / tongsuopy and other encryption libraries.

description:
  ![Python](https://badgen.net/badge/python/%3E=3.8,%3C3.12/green?icon=github)
  ![Django](https://badgen.net/badge/django/%3E=3.1.5,%3C=4.2.1/yellow?icon=github)
  [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE.txt)
  ![Release](https://badgen.net/github/release/TencentBlueKing/crypto-python-sdk)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/TencentBlueKing/crypto-python-sdk/pulls)
  [![Publish to Pypi](https://github.com/TencentBlueKing/crypto-python-sdk/actions/workflows/release.yml/badge.svg)](https://github.com/TencentBlueKing/crypto-python-sdk/actions/workflows/release.yml)
  [(English Documents Available)](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/readme_en.md)

  ️🔧 BlueKing crypto-python-sdk 是一个基于 pyCryptodome / tongsuopy 等加密库的轻量级密码学工具包，为 Python 应用统一的加解密实现，
  便于项目在不同的加密方式之间进行无侵入切换

  * [Basic] 提供加密统一抽象层，对接 Cryptodome / tongsuopy 等加密库，提供统一的加解密实现
  * [Basic] 支持国际主流密码学算法：AES、RSA
  * [Basic] 支持中国商用密码学算法：SM2、SM4
  * [Basic] 非对称加密支持 CBC、CTR、GCM、CFB 作为块密码模式
  * [Contrib] Django Support，集成 Django settings、ModelField


  ```bash
  $ pip install bk-crypto-python-sdk
  ```

  > 更多用法参考：[使用文档](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/docs/usage.md)

  **非对称加密**
  ````python
  from bkcrypto import constants
  from bkcrypto.asymmetric import options
  from bkcrypto.asymmetric.ciphers import BaseAsymmetricCipher
  from bkcrypto.contrib.basic.ciphers import get_asymmetric_cipher
  asymmetric_cipher: BaseAsymmetricCipher = get_asymmetric_cipher(
      cipher_type=constants.AsymmetricCipherType.SM2.value,
      
      cipher_options={
          constants.AsymmetricCipherType.SM2.value: options.SM2AsymmetricOptions(
              private_key_string=None
          ),
          constants.AsymmetricCipherType.RSA.value: options.SM2AsymmetricOptions(
              private_key_string=None
          ),
      }
  )

  assert "123" == asymmetric_cipher.decrypt(asymmetric_cipher.encrypt("123"))

  assert asymmetric_cipher.verify(plaintext="123", signature=asymmetric_cipher.sign("123"))
  ````
  **对称加密**
  ```python
  import os
  from bkcrypto import constants
  from bkcrypto.symmetric.ciphers import BaseSymmetricCipher
  from bkcrypto.contrib.basic.ciphers import get_symmetric_cipher
  symmetric_cipher: BaseSymmetricCipher = get_symmetric_cipher(
      cipher_type=constants.SymmetricCipherType.SM4.value,
      common={"key": os.urandom(16)},
  )
  assert "123" == symmetric_cipher.decrypt(symmetric_cipher.encrypt("123"))
  ```

  在 Django Settings 中配置加密算法类型
  ```python
  from bkcrypto import constants
  BKCRYPTO = {
      
      "ASYMMETRIC_CIPHER_TYPE": constants.AsymmetricCipherType.SM2.value,
      
      "SYMMETRIC_CIPHER_TYPE": constants.SymmetricCipherType.SM4.value,
  }
  ```
  **非对称加密**
  ```python
  from bkcrypto.asymmetric.ciphers import BaseAsymmetricCipher
  from bkcrypto.contrib.django.ciphers import get_asymmetric_cipher
  asymmetric_cipher: BaseAsymmetricCipher = get_asymmetric_cipher()

  assert "123" == asymmetric_cipher.decrypt(asymmetric_cipher.encrypt("123"))

  assert asymmetric_cipher.verify(plaintext="123", signature=asymmetric_cipher.sign("123"))
  ```
  **对称加密**
  ```python
  from bkcrypto.symmetric.ciphers import BaseSymmetricCipher
  from bkcrypto.contrib.django.ciphers import get_symmetric_cipher
  symmetric_cipher: BaseSymmetricCipher = get_symmetric_cipher()
  assert "123" == symmetric_cipher.decrypt(symmetric_cipher.encrypt("123"))
  ```

  在 Django Settings 中配置加密算法类型
  ```python
  from bkcrypto import constants
  from bkcrypto.symmetric.options import AESSymmetricOptions, SM4SymmetricOptions
  from bkcrypto.asymmetric.options import RSAAsymmetricOptions, SM2AsymmetricOptions
  BKCRYPTO = {
      
      "ASYMMETRIC_CIPHER_TYPE": constants.AsymmetricCipherType.SM2.value,
      
      "SYMMETRIC_CIPHER_TYPE": constants.SymmetricCipherType.SM4.value,
      "SYMMETRIC_CIPHERS": {
          
          "default": {
              
              
              
              
              
              
              
              
              
              "common": {"key": "your key"},
              "cipher_options": {
                  constants.SymmetricCipherType.AES.value: AESSymmetricOptions(key_size=16),
                  
                  constants.SymmetricCipherType.SM4.value: SM4SymmetricOptions(mode=constants.SymmetricMode.CTR)
              }
          },
      },
      "ASYMMETRIC_CIPHERS": {
          
          "default": {
              "common": {"public_key_string": "your key"},
              "cipher_options": {
                  constants.AsymmetricCipherType.RSA.value: RSAAsymmetricOptions(
                      padding=constants.RSACipherPadding.PKCS1_v1_5
                  ),
                  constants.AsymmetricCipherType.SM2.value: SM2AsymmetricOptions()
              },
          },
      }
  }
  ```
  **非对称加密**
  使用 `asymmetric_cipher_manager` 获取 `BKCRYPTO.ASYMMETRIC_CIPHERS` 配置的 `cipher`
  ```python
  from bkcrypto.asymmetric.ciphers import BaseAsymmetricCipher
  from bkcrypto.contrib.django.ciphers import asymmetric_cipher_manager
  asymmetric_cipher: BaseAsymmetricCipher = asymmetric_cipher_manager.cipher(using="default")

  assert "123" == asymmetric_cipher.decrypt(asymmetric_cipher.encrypt("123"))

  assert asymmetric_cipher.verify(plaintext="123", signature=asymmetric_cipher.sign("123"))
  ```
  **对称加密**
  使用 `symmetric_cipher_manager` 获取 `BKCRYPTO.SYMMETRIC_CIPHERS` 配置的 `cipher`
  ```python
  from bkcrypto.symmetric.ciphers import BaseSymmetricCipher
  from bkcrypto.contrib.django.ciphers import symmetric_cipher_manager

  symmetric_cipher: BaseSymmetricCipher = symmetric_cipher_manager.cipher(using="default")
  assert "123" == symmetric_cipher.decrypt(symmetric_cipher.encrypt("123"))
  ```
  **Django ModelField**
  ```python
  from django.db import models
  from bkcrypto.contrib.django.fields import SymmetricTextField
  class IdentityData(models.Model):
      password = SymmetricTextField("密码", blank=True, null=True)
  ```

  - [版本日志](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/release.md)

  - [蓝鲸论坛](https://bk.tencent.com/s-mart/community)
  - [蓝鲸 DevOps 在线视频教程](https://bk.tencent.com/s-mart/video/)
  - [蓝鲸社区版交流群](https://jq.qq.com/?_wv=1027&k=5zk8F7G)

  - [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-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)是一套运维脚本管理系统，具备海量任务并发处理能力。

  如果你有好的意见或建议，欢迎给我们提 Issues 或 Pull Requests，为蓝鲸开源社区贡献力量。
  [腾讯开源激励计划](https://opensource.tencent.com/contribution) 鼓励开发者的参与和贡献，期待你的加入。

  基于 MIT 协议， 详细请参考 [LICENSE](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/LICENSE.txt)


pkgId: 14bae625e79bc16bd1dce6afa88b82d51c4cfedd57ca27f5c0b47c10a0d703cd
name: python-bk-notice-sdk
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: A project for fetching and displaying announcement notifications.
url: https://pypi.org/project/bk-notice-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bk-notice-sdk-1.3.2-1.src.rpm
checksum_type: sha256
description:
  > PS: 使用本sdk需要到对应环境网关的 apigw 申请权限

  以下为使用本功能模块的简单配置：

  1. 安装版本获取平台公告模块(内部仓库)：

      ```
      pip install bk-notice-sdk
      ```

  2. 在项目配置文件中的**INSTALLED_APPS**内添加**bk_notice_sdk**：

      ```
      INSTALLED_APPS += (
          'bk_notice_sdk'
      )
      ```

  3. 在项目的`urls.py`中配置路由：

     ```
     urlpatterns = [
         ...,
         url(r'^notice/', include(('bk_notice_sdk.urls', 'notice'), namespace='notice')),
     ]
     ```
     接入系统可根据需要修改路由前缀。

  4. 配置环境变量(也可以在`settings.py`中配置, 见下)
     ```
     
     BK_API_URL_TMPL = "http://bkapi.example.com/api/{api_name}/"
     ```
  5. 如果需要自定义配置，在`settings.py`中添加如下配置：
      ```
      BK_NOTICE = {
          'STAGE': 'stage', # 默认读取环境变量，如果读取不到默认为'prod'
          'LANGUAGE_COOKIE_NAME': "xxx", # 若不配置默认 blueking_language
          'DEFAULT_LANGUAGE': 'en', # 默认语言
          'PLATFORM': 'xxx', # 平台注册的 code，用于获取系统通知消息时进行过滤，默认使用 app_code
          'BK_API_URL_TMPL': "http://bkapi.example.com/api/{api_name}/", # 若不配置则读取环境变量
          'BK_API_APP_CODE': 'xxx', # 用于调用 apigw 认证，默认获取 SaaS 的 APP_CODE
          'BK_API_SECRET_KEY': 'xxx', # 用于调用 apigw 认证，默认获取 SaaS 的 SECRET_KEY
      }
      ```
     上述配置按需配置即可，没有的配置项将使用默认值
  6. 注册平台

     如果需要注册本平台到通知中心可以执行以下命令:
     ```
     python manage.py register_application
     ```
     > PS: 若本地调试不需要注册平台则不需要执行该命令或者执行以下命令跳过
     ```
     python manage.py register_application --skip
     ```
  7. 启动项目：

      ```
      python manage.py runserver
      ```
  8. 可用接口

     | 路由       | 方法   | 参数 | 描述     |
        |----------|------|----|--------|
     | announcements/ | GET  | 无  | 获取平台公告 |

     **示例：**
     项目运行后，访问[http://ip:port/notice/announcements/]()即可获取当前**platform**(平台)的公告。

     `注意: 这里的 notice 路由，若在 settings.py 自定义了 ENTRANCE_URL 则为对应的路由`


pkgId: 2b124743d2b8b697312a10a0c3156119e52586df37eeef80a65205f58a488d7b
name: python-bk-resource
arch: src
version: 0.4.12
epoch: 0
release: 1
summary: Bk Resource
url: https://bk.tencent.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bk-resource-0.4.12-1.src.rpm
checksum_type: sha256
description:
  ![logo.png](assests/logo.png)

  [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/TencentBlueKing/bk-resource/blob/main/LICENSE.txt)
  [![Release Version](https://img.shields.io/badge/release-0.4.12-brightgreen.svg)](https://github.com/TencentBlueKing/bk-resource/releases)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/TencentBlueKing/bk-resource/pulls)
  [![codecov](https://codecov.io/gh/TencentBlueKing/bk-resource/branch/main/graph/badge.svg)](https://codecov.io/gh/TencentBlueKing/bk-resource)
  [![Unittest Py3](https://github.com/TencentBlueKing/bk-resource/actions/workflows/unittest.yml/badge.svg)](https://github.com/TencentBlueKing/bk-resource/actions/workflows/unittest.yml)

  [(English Documents Available)](readme_en.md)



  `bk_resource` 是一个基于 [Blueapps](https://github.com/TencentBlueKing/blueapps) 和 [Django Rest Framework](https://github.com/encode/django-rest-framework) 的脚手架，
  旨在帮助开发人员快速生成符合 [`12-factor`](https://12factor.net/) 规范的 WEB SaaS，并在`DDD`开发实践中方便地创建可扩展的领域服务



  - [Basic] 基于 `Django` 进行封装，生成标准 `swagger API`
  - [Basic] 基于 `django-environ` 适配环境变量与 `.env` 配置
  - [Basic] 支持基于 `PEP-621` 的全工具链 (mypy\isort\flake8\black) 配置方案
  - [Basic] 支持代码规范类工具整合：`pre-commit`、`code-cc`
  - [Resource] 集成 `bk_resource` 组织工程目录结构，通过 `Resource` 的方式声明业务逻辑
  - [Resource] 支持 `ApiResource` / `BkApiResource` 调用第三方 `API` 接口





  1. 安装`cruft`

  ```bash
  $ pip install cruft
  ```

  2. 通过`cruft`脚本架生成项目

  ```bash
  $ cruft create https://github.com/TencentBlueKing/bk-resource.git --checkout main --directory template
  ```

  3. 添加远程仓库地址并完成推送

  ```bash
  cd {{ project_id }}
  git init
  git add .
  git commit -m "init repo"
  git remote add origin {{ git_url }}
  git push -u origin master
  ```



  检查或更新模板前需确保本地代码已提交到 GIT 仓库

  1. 检查模板是否更新

  ```bash
  $ cruft check --checkout main
  ```

  2. 合并模板到本地项目

  ```bash
  $ cruft update --checkout main
  ```



  - [快速开始](template/readme.md)
  - [使用文档](docs/usage.md)



  ![ddd](assests/framework.png)

  - Api 交互层
      通过 UI Api 或者 Open Api 将服务暴露给用户，由对应的 Api 负责对应的业务逻辑串联。
  - Scene 场景层
      在通过 Api 访问后端时，实际访问的是由 Resource 暴露的一个场景服务，通过场景服务串联领域层的业务逻辑。
  - Domain 领域层
      领域层聚焦对应的细分模块，负责处理模块的具体业务逻辑，例如，在用户模块中，处理用户注册、登录、修改密码、重置密码等逻辑。
  - Model 模型层
      在 MVC 框架中 (如 Django)，将代码架构划分为 Model (模型)，View (视图)，Controller (控制器) 三层，View 用于界面展示，在前后端分离开发部署的实践中，已经不再由后端处理，后端只需要处理 Model & Controller。



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



  - [蓝鲸论坛](https://bk.tencent.com/s-mart/community)
  - [蓝鲸 DevOps 在线视频教程](https://bk.tencent.com/s-mart/video/)
  - [蓝鲸社区版交流群](https://jq.qq.com/?_wv=1027&k=5zk8F7G)



  - [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-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)是一套运维脚本管理系统，具备海量任务并发处理能力。



  如果你有好的意见或建议，欢迎给我们提 Issues 或 Pull Requests，为蓝鲸开源社区贡献力量。
  [腾讯开源激励计划](https://opensource.tencent.com/contribution) 鼓励开发者的参与和贡献，期待你的加入。



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


pkgId: 48f2c11f36dd1c9fe4ed5dc893eabeb669d180955a7670208e75477eb4bf94bb
name: python-bkmeans
arch: src
version: 1.3
epoch: 0
release: 1
summary: The breathing k-means algorithm
url: https://github.com/gittar/bkmeans
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bkmeans-1.3-1.src.rpm
checksum_type: sha256
description:
  An approximation algorithm for the *k*-means problem that (on average) is **better** (higher solution quality) and **faster** (lower CPU time usage) than  ***k*-means++** (in the widely-used implementation from `scikit-learn` and with `n_init=10`, the longtime default value for repetitions).

  **Remark**: Version 1.4 of `scikit-learn` (released 1/2024) introduced a new default value `n_init=1` for ***k*-means++**. As a consequence, the advantage of **breathing *k*-means** in solution quality has become even larger but ***k*-means++** is faster now (by sacrificing solution quality).

  **Technical Report:**
  https://arxiv.org/abs/2006.15666

  **Example Code:** [Google Colab notebook](https://colab.research.google.com/drive/1tT3lPJQqSIzQ7NuIhRa8DlSU11lO9jgo?usp=sharing)


  The included class **BKMeans** is subclassed from [scikit-learn's **KMeans** class](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html)
  and has, therefore, **the same API**. It can be used as a plug-in replacement for scikit-learn's **KMeans**.

  There is one new parameter that can be ignored (meaning: left at default) for normal usage:

  * *m* (breathing depth), default: 5

  The parameter *m* can also be used, however, to generate faster ( 1 < *m* < 5) or better (*m*>5) solutions. For details see the above technical report.




  * bug fix: BKMeans.predict(df) now matches BKMeans.labels_
  * bug fix: BKMeans is now fully deterministic if parameter random_state is set to non-Null
  * compatibility with scikit-learn: unused parameter *y* was not set in the `fit` method

  Remark: the fixed bugs did not affect the quality of the codebook results in previous version


  * make use of the optional `sample_weight` parameter in the `fit` method
  * (contributed by Björn Wiescholek)


  * speed improvement by setting `n_init=1` by default
  * close centroids now defined by nearest neighbor criterion
  * parameter `theta` abolished


  * (initial release)
  * "close centroids" were based on distance and a parameter *theta*


  Code:
  ```python
  import numpy as np
  from bkmeans import BKMeans


  X=np.random.rand(1000,2)


  bkm = BKMeans(n_clusters=100)


  bkm.fit(X)


  print(bkm.inertia_)
  ```
  Output:
  ```
  1.1775040547902602
  ```


  Code:
  ```python
  import numpy as np
  from sklearn.cluster import KMeans
  from bkmeans import BKMeans
  import time


  X=np.random.rand(1000,2)


  k=100

  for i in range(5):
      
      kmp = KMeans(n_clusters=k, n_init=10)
      kmp.fit(X)

      
      bkm = BKMeans(n_clusters=k)
      bkm.fit(X)

      
      imp = 1 - bkm.inertia_/kmp.inertia_
      print(f"SSE improvement over k-means++: {imp:.2%}")
  ```
  Output:

  ```
  SSE improvement over k-means++: 3.38%
  SSE improvement over k-means++: 4.16%
  SSE improvement over k-means++: 6.14%
  SSE improvement over k-means++: 6.79%
  SSE improvement over k-means++: 4.76%
  ```


pkgId: edc1b0c967736fd0db93df2087465d3273b256c95ec132c1f442ab87407334f5
name: python-bkrdoc
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: This project aims to provide tools for automated documentation generation for BeakerLib tests.
url: https://github.com/rh-lab-q/bkrdoc
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bkrdoc-1.3.0-1.src.rpm
checksum_type: sha256
description:
  bkrdoc

  This project aims to provide tools for automated documentation generation for BeakerLib tests.
  1. Introduction
  1.1 What is bkrdoc?

  bkrdoc is a documentation generator from tests written using BeakerLib library. This generator makes documentation from test code with and also without any documentation markup.
  1.2 What it`s good for?

  For fast, brief and reliable documentation creation. It`s good for quick start with unknown BeakerLib test. Created documentations provides information about the documentation credibility. Also created documentations shows environmental variables and helps reader to run test script from which was documentation created.

  bkrdoc is written in pure python.
  1.3 What is BeakerLib?

  BeakerLib is a shell-level integration testing library, providing convenience functions which simplify writing, running and analysis of integration and blackbox tests.

  https://fedorahosted.org/beakerlib/
  1.4 How is bkrdoc licensed?

  BSD license. See the LICENSE file in the distribution.
  1.5 Contact details

  Feel free to send me an email (Kulda12@seznam.cz) for any question you have on bkrdoc project.
  2. Installing
  2.1 Prerequisites

      bkrdoc was tested on Python 2.7 and 3.3 versions on Linux.
      bkrdoc has no external dependencies.

  2.2 Installation process

  Installation is very simple. You have two choices. First is to download rpm from bkrdoc pypi and easily install it. Second choice is to download whole project and after that run setup.py script in bkrdoc folder. For executing setup.py file you need to run this standard python setup.py install command.
  3. Using
  3.1 Basic usage

  After installation of bkrdoc rpm you can easily run bkrdoc by typing bkrdoc in command line. You can see on these examples:

  for analysis:
  bkrdoc analysis [analysis-options] [BeakerLib_test.sh]

  for markup:
  bkrdoc markup [markup-options] [BeakerLib_test.sh]

  3.2 Documentation tags

  First important thing is that all documentation comments must start with #@. For example this code comment #@ Makes temporary directory and saves work in it will create this documentation line: Makes temporary directory and saves work in it.

  If a documentation comment is before BeakerLib phase, function, loop or condition this comment will be taken as a description. You can see what will happen on this example:

    
    rlPhaseStartTest "various argument types"

      
      for arg in disabled EnAbLeD dIsAblEd enabled no Yes nO yes 0 1
      do
          
          rlRun "abrt-auto-reporting $arg"
      done
      
    rlPhaseEnd

  result:

    Test "various argument types"
      Various types of arguments will start this part
        loop: for every argument in selected word will do...
          Report argument
        Reporting finished

  In the top of every generated documentation are three lines consisting of description, information about authors and keywords of the test. These three lines are generated from test template. But it can occur that the template is missing or you want to add more data and that you can do using these tags: @keyword, @key, @author and @description. For example: #@ @key httpd will add key into keywords line:

  Description: Simple test
  Author: Jan Kresla
  Keywords: httpd

  Also tagged generator supports block comments. Each block comment must start with #@ as you can see on this example:

      
      
      
      rlPhaseStartSetup
          TmpDir=$(mktemp -d)
          pushd $TmpDir
      rlPhaseEnd

  will generate:

    Setup
      Somenthing in start of the test
      Could be anything
      Make temporary directory and saves work in it

  useful feature is that bkrdoc generator could use existing BeakerLib command comment as you can see from below example:

  rlPhaseStartSetup
    rlRun 'ps aux' 'ps command should not traceback' #@
    rlRun 'ps aux' 'ps command should not traceback' #@ check for traceback
  rlPhaseEnd

  will reproduce:

  Setup
    ps command should not traceback
    check for traceback

  Also markup version supports initial comment as a global whole test comment. This initial comment or block comment must be after shebang(also could be after test description made by beaker-wizard) and must start as usuall with #@. You can see little example below:







  PACKAGE="httpd"
  HttpdPages="/var/www/html"
  HttpdLogs="/var/log/httpd"
  .
  .

  will reproduce:

  Description: -
  Author: -
  Purpose: This is the first line of initial documentation comment
           second line
           third line
  Keywords: -
  .
  .

  4. Package contents

  After downloading bkrdoc project, you will see following files and directories:

  README.md: This README file.

  LICENSE: File with bkrdoc license.

  bkrdoc/: Folder with bkrdoc generator which is creating documentations from BeakerLib tests with and without any documentation markup.

  bkrdoc/analysis/: Folder with sources for automated documentation generator without documentation markup

  bkrdoc/markup/: Folder with sources for automated documentation generator with documentation markup

  examples/: This folder contains some BeakerLib tests and generated documentations

  docs/: Folder contains TODO options and first documentation format.

  tests/: Folder contains files for bkrdoc testing
  5. CI Status

  bkrdoc is automatically tested by Travis CI


pkgId: 21480dc312c7b7723fd2356b3c98b975a038274a8f040bc6e93c6a32f3778ac1
name: python-bkstorages
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: File storage backends for blueking PaaS platform
url: https://pypi.org/project/bkstorages/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bkstorages-2.0.0-1.src.rpm
checksum_type: sha256
description:
  bkstorages 帮助你在蓝鲸 Django 应用中轻松使用 ***蓝鲸制品库*** 和 [S3 对象存储](https://docs.ceph.com/en/latest/radosgw/s3/) 以管理用户上传文件


  ```bash
  $ pip install bkstorages
  ```



  安装好模块后，在你的 Django 配置文件中添加：

  ```python

  RGW_ACCESS_KEY_ID = ''
  RGW_SECRET_ACCESS_KEY = ''
  RGW_STORAGE_BUCKET_NAME = ''


  RGW_ENDPOINT_URL = 'http://radosgw.example.com/'
  ```

  如果要用蓝鲸对象存储服务来保存所有的用户上传文件，请在配置文件中添加：

  ```python
  DEFAULT_FILE_STORAGE = 'bkstorages.backends.rgw.RGWBoto3Storage'
  ```

  之后项目中所有的 `FileField` 与 `ImageField` 都会将用户文件上传至蓝鲸对象存储服务。

  默认情况下，上传新文件会覆盖同名旧文件，你可以通过修改 `RGW_FILE_OVERWRITE` 配置项来关闭。

  关于 Django storage 的更多说明请参考： [Django document: File Storage](https://docs.djangoproject.com/en/3.2/topics/files/#file-storage)



  如果要使用蓝鲸对象存储服务托管静态文件，请在配置文件中添加：

  ```
  STATICFILES_STORAGE = 'bkstorages.backends.rgw.StaticRGWBoto3Storage'
  ```

  之后每次执行 `python manage.py collectstatic` 时，django 会自动将所有文件上传到你配置的 bucket 中。

  与 RGWBoto3Storage 不同，StaticRGWBoto3Storage 默认修改了以下几个配置：

  - 所有文件会被默认上传至 `/static/` 目录下，可通过 `RGW_STATIC_LOCATION` 参数修改
  - 默认为文件添加以下头信息，可通过 `RGW_STATIC_OBJECT_PARAMETERS` 参数修改：
      - **Cache-Control**: max-age=86400



  如果通过修改配置文件满足不了你的需求，你随时可以通过继承 `RGWBoto3Storage` 的方式来自定义你自己的 storage：

  ```python
  class MyStaticRGWBoto3Storage(RGWBoto3Storage):
      """My Storage class for storing static files
      """
      bucket_name = 'another_bucket'
      location = '/my_static_path'
      object_parameters = {
          
          'Expires': 'Wed, 30 Nov 2016 04:12:29 GMT',
          
          'CacheControl': 'max-age=86400'
      }


  STATICFILES_STORAGE = 'custom_backend.MyStaticRGWBoto3Storage'
  ```

  如需使用更丰富的 `object_parameters` 配置参数，请访问 [Boto3 相关文档](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html#S3.Client.put_object) 查阅相关文档。



  你需要同时修改模板文件中的静态文件地址，才能指向到蓝鲸对象存储服务上的文件。

  **Django 模板**：

  ```html
  {% load staticfiles %}
  <script type="text/javascript" src="{{ static 'js/settings.js' }}"></script>
  ```

  **Mako 模板**：

  ```html
  <%
      from django.contrib.staticfiles.templatetags.staticfiles import static
  %>
  <script type="text/javascript" src="${static('js/settings.js')}"></script>
  ```



  除了将 `RGWBoto3Storage` 指定为文件存储后端外，你还可以通过 API 来手动使用它来管理文件。

  初始化 storage 对象：

  ```python
  from bkstorages.backends.rgw import RGWBoto3Storage


  storage = RGWBoto3Storage()
  ```

  使用 storage 对象上传文件：

  ```python


  from django.utils.encoding import force_bytes
  content = force_bytes('Hello, RGW!')


  f = ContentFile(content)
  storage.save(u'/test/hello', f)
  ```

  上传文件对象：

  ```python
  from tempfile import NamedTemporaryFile

  from django.core.files import File
  from django.utils.encoding import force_bytes


  with NamedTemporaryFile() as fp:
      fp.write(force_bytes('Temp file'))
      fp.flush()

      f = File(fp)
      storage.save(u'/test/temp_file.txt', f)
  ```

  查看文件链接：

  ```python
  storage.url('/test/temp_file.txt')
  ```

  列出目录下所有文件：

  ```python
  storage.listdir('/test')
  ```

  删除文件：

  ```python
  storage.delete('/test/temp_file.txt')
  ```

  更多 API 说明请参考：[File storage API - Django documentation](https://docs.djangoproject.com/en/3.2/ref/files/storage/#the-storage-class)




  - 模块所有可配置项列表详见项目 Wiki



  首先安装 [poetry](https://github.com/python-poetry/poetry) ，之后在项目目录下执行 `poetry env use python3.11` 初始化开发用虚拟环境。然后用 `poetry shell` 命令激活虚拟环境。

  - 执行 `poetry install` 安装所有依赖
  - 使用 `pytest -s .` 执行所有单元测试



  为了测试包在不同 Python 版本下的稳定性，我们使用了 tox 工具。在项目目录下执行 `tox` 即可执行所有的单元测试。



  首先，执行 `poetry build` 命令在 dist 目录下生成当前版本的包。然后执行 `twine upload dist/* --repository-url {pypi_address} --username {your_name} --password {your_token}` 将其上传到 pypi 服务器上。


pkgId: 76f96e5be6eb220fa12a0283e91447a53e4f2f88bdeab29b24ccd652823623bb
name: python-bl_hector
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: A collection manager.
url: https://git.easter-eggs.org/bioneland/hector
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bl_hector-0.4.5-1.src.rpm
checksum_type: sha256
description:
  Hector is available on PyPI under the name `bl_hector`.
  To install, just run `python -m pip install bl_hector`.




  Hector is configured using environment variables.
  See [the `settings` module](bl_hector/infrastructure/settings.py) for
  a comprehensive list of configuration variables.

  All the variable names must be prefixed with `HECTOR_`. For instance :

  ```console

  $ export HECTOR_SECRET_KEY="XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"


  $ export HECTOR_DSN="sqlite:///data.sqlite"
  ```




  To enable WebAuthn authentication, you must install extra dependencies (`bl-hector[webauthn]`)
  and enable it explicitly:

  ```console
  $ export HECTOR_WEBAUTHN_ENABLED=1
  ```

  TOTP authentication is provided to be able to login on servers that do not (yet) support
  the `cryptography` module. You must install extra dependencies (`bl-hector[totp]`)
  and enable it explicitly by setting a base32 random secret:

  ```console

  $ export HECTOR_TOTP_SECRET=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  ```

  Note that it is a highly insecure way of authenticating, as anyone gaining access to your
  OTP generator would be able to login.




  Once configured, you must initialise Hector's database with the dedicated command:

  ```console
  $ hector init-db
  ```




  Hector being a Flask application, it can be run using any WSGI server,
  for instance, with [Gunicorn](https://gunicorn.org):

  ```console
  $ gunicorn --access-logfile="-" -w 4 -b 127.0.0.1:3000 "bl_hector.configuration.wsgi:app()"
  ```




  See [CONTRIBUTING.md]() to set up a development environment.


pkgId: 5762d2d4aa06054e49b84c0723e296a122ae8279b1370576f85d431e6a9c8945
name: python-blabel
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Generate multi-page, multi-label pdfs in Python.
url: https://github.com/Edinburgh-Genome-Foundry/blabel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blabel-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Blabel is a Python package to generate labels (typically for printing stickers)
  with barcodes and other niceties.
  **Some features:**
  - Generates PDF files where each page is a label (that's the way most label printers want it).
  - Label layout is defined by HTML (Jinja) templates and CSS. Supports any page dimensions and margins.
  - Builtin support for various barcodes, QR-codes, datamatrix, and more (wraps other libraries).
  - Labels data can be provided as list of dicts (easy to generate from spreadsheets).
  - Possibility to print several items per sticker.


pkgId: ca120382c3e57423cc2608ad6570129ac897a58a6b2af48e1de3c090ef4389fc
name: python-blablabla
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: A simple application to enable voice activated chatbot
url: https://github.com/oozut/blablabla
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blablabla-0.0.16-1.src.rpm
checksum_type: sha256
description:
  **Project Blablabla: Conversational AI for the Modern Era**

  Imagine a world where interacting with artificial intelligence is as natural as chatting with a friend 🤖. Welcome to Blablabla, a pioneering voice-activated chat interface that's taking the first step towards making human-AI conversations a reality 💬.

  **Current Focus: Live Transcription**

  We're excited to announce that our platform now offers live transcription capabilities, allowing users to effortlessly convert spoken words into written text in real-time 💻. This innovative feature sets the stage for a more intuitive and seamless interaction with artificial intelligence 🎉.

  **Live Transcription Features**

  Accurate and Instantaneous: Our platform provides highly accurate and instantaneous transcription of spoken words, empowering users to focus on the conversation rather than note-taking 📝.
  Real-time Feedback: Get immediate feedback on your conversations, enabling more effective communication and collaboration 📊.

  **Running the tool**

  For now, just running using python:
  ```python -c "import blablabla; blablabla.start_all()"```

  **Future Roadmap**

  While live transcription is just the beginning, we envision a future where Blablabla enables conversational interactions with Large Language Models (LLMs) and other AI systems 🔜. Our ultimate goal is to create a platform that allows humans to engage with AI in a natural, intuitive, and conversational way 💡 that you can control !

  [ ] Enable faster transcription by avoiding encoding multiple time the same audio file.
  [ ] Enabling speculative decoding for repeated transcription
  [ ] Integrate with other LLM to provide question answer from speech

  **Inspiration:**

  This project was inspired by [whisper_streaming](https://github.com/ufal/whisper_streaming) and [whisper-writer](https://github.com/savbell/whisper-writer).


pkgId: 9de410237d4f107cb391081a2df442be8bb9a7191fb6b177274bb7ee04f24136
name: python-black-codeclimate
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Convert black --diff output to a Code Climate report
url: https://github.com/steinuil/black-codeclimate
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-codeclimate-1.0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/black-codeclimate.svg)](https://badge.fury.io/py/black-codeclimate)

  Convert the output of `black --diff` to a report conforming to the [Code Climate spec](https://github.com/codeclimate/platform/blob/master/spec/analyzers/SPEC.md).
  It is made to be used in GitLab CI to generate a [Code Quality report](https://docs.gitlab.com/ee/ci/testing/code_quality.html), which will show a nice widget in merge requests listing the file and the lines affected by the reformatting.

  `black-codeclimate` uses [unidiff](https://pypi.org/project/unidiff/) to parse a diff file and detect changes, and outputs a JSON array of Code Climate issue objects reporting the filename and line range of the change. In theory it could be used on any unified diff data, but I only tested it with `black --diff`'s output. Hit me up in the issues if you use it for anything else :)



  Pipe the output of `black --diff` into `black-codeclimate`:

  ```bash
  black --diff src/ | black-codeclimate > black_report.json
  ```

  Or specify a file to use as input:

  ```bash
  black-codeclimate black.diff > black_report.json
  ```

  You can also change the severity, description and check_name of the issues in the resulting report by specifying command line flags:

  ```bash
  black-codeclimate --severity blocker --description "would reformat [black]" --check-name "black" black.diff > black_report.json
  ```

  Run `black-codeclimate -h` to see a list of the available flags.



  Add this step to your `.gitlab-ci.yml` file:

  ```yaml
  lint:black:
    stage: lint
    before_script:
      - # Install black and black-codeclimate...
    script:
      
      - black --diff --check src/ > black.diff
    after_script:
      - black-codeclimate black.diff > black_report.json
    artifacts:
      reports:
        codequality: black_report.json
      when: always
  ```

  This will upload the `black_report.json` as a GitLab Code Quality artifact. The lines that would be reformatted by `black` will show up as a [merge request widget](https://docs.gitlab.com/ee/ci/testing/code_quality.html#merge-request-widget).


pkgId: a2ab1ddb801260f2bb4965256b09b70e597b9484ea59cb3a0e1a9fde920de348
name: python-black-gl-code-quality
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A simple wrapper to convert Black outputs to codeclimate report format for GitLab-CI
url: https://github.com/themimitoof/black-gl-code-quality
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-gl-code-quality-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This project aim to convert [Black](https://github.com/psf/black) report to
  [CodeClimate](https://github.com/codeclimate/platform/blob/master/spec/analyzers/SPEC.md)
  format that can be ingest by GitLab.

  ```
  → poetry run black-gl-cq src/black_gl_code_quality | jq
  [
    {
      "type": "issue",
      "description": "Black would reformat",
      "location": {
        "lines": {
          "begin": 1,
          "end": 1
        },
        "path": "src/black_gl_code_quality/__main__.py"
      },
      "severity": "major"
    },
    {
      "type": "issue",
      "description": "Black would reformat",
      "location": {
        "lines": {
          "begin": 1,
          "end": 1
        },
        "path": "src/black_gl_code_quality/error.py"
      },
      "severity": "major"
    }
  ]
  ```



  For security concerns, Docker-in-Docker has been disabled in all GitLab runners that I
  have access/manage. Because the Code Quality template shipped with GitLab instances use
  CodeClimate CLI that requires a Docker environment, we can't use it and an alternative
  solution was required to obtain Black errors in our Code Quality reports.




  Simply run the following command:

  ```
  pip install black-gl-code-quality
  ```

  If you use Poetry, you can add it to your dev-dependencies:

  ```
  poetry add --group dev black-gl-code-quality
  ```



  There is two ways to use this tool:

   - by piping Black
   - by calling `black-gl-code-quality` (or by it's alias `black-gl-cq`) directly




  Piping with Black requires to forward  `stderr` to `stdout`. You can use the following
  command in the `.gitlab-ci.yml`:

  ```
  black --check src/ 2>&1 | black-gl-cq > black-code-quality-report.json
  ```

  Here's an example for a GitLab-CI job:

  ```yaml
  lint:black:
    stage: test
    script:
      - source .venv/bin/activate
      - black --check src/ 2>&1 | black-gl-cq > black-code-quality-report.json
    artifacts:
      when: always
      reports:
        codequality: black-code-quality-report.json
  ```



  Calling `black-gl-code-quality` (or it's alias `black-gl-cq`) execute Black with the
  `--check` argument. It forwards all arguments you pass if you need to configure Black
  via the CLI.

  Specifying source folders is **MANDATORY**.

  Here's an example for a GitLab-CI job:

  ```yaml
  lint:black:
    stage: test
    script:
      - source .venv/bin/activate
      - black-gl-cq src/ > black-code-quality-report.json
    artifacts:
      when: always
      reports:
        codequality: black-code-quality-report.json
  ```

  Admit we want to skip string normalization:

  ```yaml
  lint:black:
    stage: test
    script:
      - source .venv/bin/activate
      - black-gl-cq -S src/ > black-code-quality-report.json
    artifacts:
      when: always
      reports:
        codequality: black-code-quality-report.json
  ```



  By default, all errors have the severity `major`. Depending how you consider Black issues
  important, you can change the severity for all errors returned by the report by using
  one of the following [values](https://github.com/codeclimate/platform/blob/master/spec/analyzers/SPEC.md#issues)
  with the `BLACK_GL_SEVERITY` environment variable: `info`, `minor`, `major`, `critical`, `blocker`.

  Here's an example for a GitLab-CI job:

  ```yaml
  lint:black:
    stage: test
    variables:
      BLACK_GL_SEVERITY: minor
    script:
      - source .venv/bin/activate
      - black-gl-cq src/ > black-code-quality-report.json
    artifacts:
      when: always
      reports:
        codequality: black-code-quality-report.json
  ```



  It is possible to pass the `-v` argument to `black-gl-cq` to stream Black's output to stderr.

  Here's an example:

  ```
  $ poetry run black-gl-cq -v src > black-code-quality-report.json
  Identified `/home/themimitoof/repos/black-gl-code-quality` as project root containing a .git directory.
  Sources to be formatted: "src"
  /home/themimitoof/repos/black-gl-code-quality/src/black_gl_code_quality/__init__.py wasn't modified on disk since last run.
  /home/themimitoof/repos/black-gl-code-quality/src/black_gl_code_quality/parser.py wasn't modified on disk since last run.
  /home/themimitoof/repos/black-gl-code-quality/src/black_gl_code_quality/error.py already well formatted, good job.
  /home/themimitoof/repos/black-gl-code-quality/src/black_gl_code_quality/__main__.py already well formatted, good job.

  All done! ✨ 🍰 ✨
  4 files would be left unchanged.
  ```



  In case you have a suggestion or want a new feature, feel free to open a
  [discussion](https://github.com/Themimitoof/black-gl-code-quality/discussions).

  If you found a bug, you can [open an issue](https://github.com/Themimitoof/black-gl-code-quality/issues).

  In order to maintain an overall good code quality, this project use the following tools:

   - [Black](https://github.com/psf/black)
   - [Isort](https://github.com/PyCQA/isort)
   - [Flake8](https://flake8.pycqa.org/en/latest/)

  Linting and formatting tools are configured to match the [current default rules of Black](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html).

  Please ensure to run these tools before commiting and submiting a Pull request. In case one of
  these mentionned tools report an error, the CI will automatically fail.

  In case you are able to fix by yourself a bug, enhance the code or implement a new
  feature, feel free to send a [Pull request](https://github.com/Themimitoof/black-gl-code-quality/pulls).



  This project is released under the [BSD-3 Clause](LICENSE). Feel free to use,
  contribute, fork and do what you want with it. Please keep all licenses, copyright
  notices and mentions in case you use, re-use, steal, fork code from this repository.


pkgId: ca82b697603df902c70ebc4c9a9202d85e684b5788eece78f5796091869f5d4a
name: python-black-junit
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Tool for generation JUnit's report from black/blue output
url: https://github.com/quantum-0/black-junit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-junit-0.2.5-1.src.rpm
checksum_type: sha256
description:
  This project is a tool for generation JUnit's report from black/blue output



  `pip install black-junit`



  ```bash
  black . --check --verbose 2>results.txt
  black-junit < results.txt > report.xml
  ```

  or, in case using **blue** formatter:

  ```bash
  blue . --check --verbose 2>results.txt
  black-junit < results.txt > report.xml
  ```



  [![wakatime](https://wakatime.com/badge/github/Quantum-0/black-junit.svg)](https://wakatime.com/badge/github/Quantum-0/black-junit)
  [![Black](https://github.com/Quantum-0/black-junit/actions/workflows/black.yml/badge.svg)](https://github.com/Quantum-0/black-junit/actions/workflows/black.yml)
  [![GitHub Org's stars](https://img.shields.io/github/stars/quantum-0/black-junit)](https://github.com/Quantum-0/black-junit/)
  ![PyPI - License](https://img.shields.io/pypi/l/black-junit)
  [![PyPI](https://img.shields.io/pypi/v/black-junit)](https://pypi.org/project/black-junit/)
  ![PyPI - Status](https://img.shields.io/pypi/status/black-junit)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/black-junit)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/black-junit)




  [MIT License](./LICENSE)


pkgId: 0b7d269d467a04a62fa1c0cbb85a27f34b4ea94308ca836b8c04133311926d18
name: python-black-mamba
arch: src
version: 0.6.4
epoch: 0
release: 1
url: https://mamba.black
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-mamba-0.6.4-1.src.rpm
checksum_type: sha256
summary:
  Development framework to write, test and deploy smart contracts written in Vyper and Solidity. It has integrated web3.py support.

description:
  Mamba is a framework to write, compile, and deploy smart contracts
  written in Vyper language and Solidity language. On top of that, it has supports for writing
  and testing decentralized applications using Web3.py and Pytest.



  * [Ganache](https://www.trufflesuite.com/ganache)
  * [Ganache CLI](https://github.com/trufflesuite/ganache-cli)
  * [Pip](https://pypi.org/project/pip/)
  * [Python3](https://www.python.org/downloads/) version 3.6 or greater
  * [Go Ethereum](https://geth.ethereum.org/downloads/)
  * [Vyper](https://github.com/ethereum/vyper)
  * [Solidity](https://soliditylang.org)



  You can install the latest release via ``pip``:

  ```bash
  $ pip install black-mamba
  ```

  To use Solidity, you must install ``solc`` compiler separately.



  To set up the the structure of Mamba project directory:

  ```bash
  $ mamba init
  $ edit contracts/HelloWorld.vy
  $ mamba compile
  ```



  Mamba documentation can be found at [Mamba website](https://mamba.black/documentation).




  I invite you to join Mamba squad! You can contribute to Mamba by
  writing documentation, finding bugs, and creating pull requests.


pkgId: 0e5daab35c556f3e89c597cb139f0405bd3050c4dbd14ef1584a80b596bd8529
name: python-black-nb
arch: src
version: 0.7
epoch: 0
release: 1
summary: Apply black to all code cells in a Jupyter notebook.
url: https://github.com/tomcatling/black-nb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-nb-0.7-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">The uncompromising code formatter, for Jupyter notebooks</h2>

  <p align="center">
  <img alt="Build Status" src="https://github.com/tomcatling/black-nb/workflows/Python%20application/badge.svg"></a>
  <a href="https://github.com/ambv/black"><img alt="Code Style" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  <a href="https://pepy.tech/project/black-nb"><img alt="Code Style" src="https://pepy.tech/badge/black-nb"></a>
  </p>

  *black-nb* applies [*black*](https://github.com/ambv/black) to Jupyter notebooks.

  Much of the code is taken from the original *black* project and the behaviour is intentionally similar.



  `pip install black-nb`



  To apply *black* to all code cells in notebooks under the current directory:

  ```bash
  black-nb .
  ```
  To clear cell outputs in addition to reformatting:

  ```bash
  black-nb --clear-output .
  ```

  To check if notebooks pass *black* and additionally have no output (files will be unchanged):

  ```bash
  black-nb --clear-output --check .
  ```

  To reformat all `*.ipynb` files below `./`, excluding paths matching `*/outputs/*` or `*/.ipynb_checkpoints/*`:

  ```bash
  black-nb --exclude '/(outputs|\.ipynb_checkpoints)/' .
  ```



  *black-nb* doesn't provide many options.  You can list them by running `black-nb --help`:

  ```text
  Usage: black-nb [OPTIONS] [SRC]...

    The uncompromising code formatter, for Jupyter notebooks.

  Options:
    -l, --line-length INTEGER  How many characters per line to allow.  [default:
                               88]
    --check                    Don't write the files back, just return the
                               status.  Return code 0 means nothing would
                               change.  Return code 1 means some files would be
                               reformatted.  Return code 123 means there was an
                               internal error.
    --include TEXT             A regular expression that matches files and
                               directories that should be included on recursive
                               searches.  An empty value means all files are
                               included regardless of the name.  Use forward
                               slashes for directories on all platforms
                               (Windows, too).  Exclusions are calculated first,
                               inclusions later.  [default: \.ipynb$]
    --exclude TEXT             A regular expression that matches files and
                               directories that should be excluded on recursive
                               searches. An empty value means no paths are
                               excluded. Use forward slashes for directories on
                               all platforms (Windows, too). Exclusions are
                               calculated first, inclusions later.  [default: /(
                               \.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|_build
                               |buck-out|build|dist|\.ipynb_checkpoints)/]
    --extend-exclude  TEXT     Like --exclude, but adds additional files and
                               directories on top of the excluded ones.
                               (Useful if you simply want to add to the default)
    --force-exclude   TEXT     Like --exclude, but files and directories matching
                               this regex will be excluded even when they are
                               passed explicitly as arguments.
    --stdin-filename  TEXT     The name of the file when passing it through stdin.
                               Useful to make sure Black will respect --force-exclude
                               option on some editors that rely on using stdin.
    -q, --quiet                Don't emit non-error messages to stderr. Errors
                               are still emitted, silence those with
                               2>/dev/null.
    -v, --verbose              Also emit messages to stderr about files that
                               were not changed or were ignored due to
                               --exclude=.
    --clear-output             Clear cell output as part of formatting.
    --config FILE              Read configuration from PATH.
    -h, --help                 Show this message and exit.
  ```



  Copyright © 2019 Tom Catling, Liam Coatman.

  `black-nb` is distributed under the terms of the [MIT licence].

  [mit licence]: https://opensource.org/licenses/MIT


pkgId: 4304d0b78255a5dac49ad869b995b6248c8559b92e7cf2fe1ffaa6dbcf3c59c1
name: python-black-nbconvert
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Apply black to ipynb files
url: https://github.com/dfm/black_nbconvert
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-nbconvert-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Tired of having to *think* about formatting in Jupyter notebooks?
  Look no further!
  This script will correctly format your Jupyter notebooks for you using [black](https://black.readthedocs.io).

  **Warning: This project will overwrite your notebooks in place.
  It shouldn't change anything except the format, but use at your own risk!**



  To install:

  ```bash
  pip install black_nbconvert
  ```

  To check a notebook:

  ```bash
  black_nbconvert --check /path/to/a/notebook.ipynb
  ```

  To fix the formatting in a notebook (in place):

  ```bash
  black_nbconvert /path/to/a/notebook.ipynb
  ```

  If you pass a directory instead of a notebook file, notebooks will be found recursively below that directory.
  For example:

  ```bash
  black_nbconvert .
  ```

  will fix the formatting for all notebooks in the current directory and (recursively) below.

  *Configuration:* Configuration for `black` in a `pyproject.toml` file above the target files will be respected.



  Use [pre-commit](https://pre-commit.com/).
  Once you [have it installed](https://pre-commit.com/#install), add this to the `.pre-commit-config.yaml` in your repository:

  ```yaml
  repos:
  - repo: https://github.com/dfm/black_nbconvert
    rev: v0.3.0
    hooks:
    - id: black_nbconvert
  ```

  Then run `pre-commit install` and you're ready to go.


pkgId: 8bd7f7713c78518cd104004731f2549c680ea0f5c131e585c8628a0485352ccf
name: python-black-with-tabs
arch: src
version: 22.10.0
epoch: 0
release: 1
summary: The somewhat compromised code formatter.
url: https://github.com/psf/black
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-black-with-tabs-22.10.0-1.src.rpm
checksum_type: sha256
description:
  **IMPORTANT**
  _Black (with tabs)_ does NOT provide a separate command line interface from the original
  _Black_. It's still just `black`. So, they cannot coexist (without virtual environments,
  anyways). Pick one!


pkgId: 3e9a3649662a972e1305c4f77b9a81b107be7a0e3f44f6ff7a15e1be29ea64a7
name: python-blackarrow
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: A fast keyword searcher
url: https://github.com/TheDataLeek/black-arrow
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blackarrow-1.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Test Status](https://travis-ci.org/TheDataLeek/black-arrow.svg?branch=master)](https://travis-ci.org/TheDataLeek/black-arrow)
  [![Coverage Status](https://coveralls.io/repos/github/TheDataLeek/black-arrow/badge.svg?branch=master)](https://coveralls.io/github/TheDataLeek/black-arrow?branch=master)
  It's basically just grep in python... Nothing fancy, just an easy extensible way
  to find things....
  Yeah, I know, it's "reinventing the wheel" but ehhh, this is easier to extend to
  cover any and all weird cases without having to memorize a bunch of obscure
  combinations of bash commands.
  That out of the way, let's talk about what this *actually does*...

  Essentially Black Arrow (or `ba` for short) is a way to search through every line in every file and
  find matching keyword *or* regular expressions. It uses smart case, so if the search term is all
  lowercase it defaults to case-insensitive (mostly for ease of use).
  ![png](./img/demo.png)
  You can also supply it with regular expressions and it handles them natively.
  ![png](./img/demo2.png)
  Other features include -
  * excluding certain files or paths,
  * replacing any matches that have been found,
  * specifying the max depth to search (good for large directory structures),
  * "pipe" mode for unix piping,
  * open the files in the `$EDITOR` for manual parsing.

  ```
  ┬─[zoe@fillory:~/Dropbox/Projects/black-arrow]─[09:22:12 PM]
  ╰─>$ pip install --user blackarrow
  ```

  ```bash
  ┬─[zoe@fillory:~/Dropbox/Projects/black-arrow]─[09:33:40 PM]
  ╰─>$ ./black-arrow/blackarrow.py -h
  usage: ba [-h] [-d DIRECTORIES [DIRECTORIES ...]] [-i IGNORE [IGNORE ...]]
            [-f FILENAME [FILENAME ...]] [-w WORKERS] [-p] [-e] [-l]
            [-r REPLACE] [-D DEPTH] [--dev]
            R
  positional arguments:
    R                     Search term (regular expression)
  optional arguments:
    -h, --help            show this help message and exit
    -d DIRECTORIES [DIRECTORIES ...], --directories DIRECTORIES [DIRECTORIES ...]
                          Director(y|ies) to run against
    -i IGNORE [IGNORE ...], --ignore IGNORE [IGNORE ...]
                          Things to ignore (regular expressions)
    -f FILENAME [FILENAME ...], --filename FILENAME [FILENAME ...]
                          Filename search term(s)
    -w WORKERS, --workers WORKERS
                          Number of workers to use (default numcores, with
                          fallback 6 unless set)
    -p, --pipe            Run in "pipe" mode with brief output
    -e, --edit            Edit the files?
    -l, --lower           Check strict lower case?
    -r REPLACE, --replace REPLACE
                          Replace text found in place with supplied
    -D DEPTH, --depth DEPTH
                          Directory depth to search in
    --dev                 Run in development mode (NO OUTPUT)
  ```

  *"Arrow! Black arrow! I have saved you to the last. You have never failed me and
  I have always recovered you. I had you from my father and he from of old. If
  ever you came from the forges of the true king under the Mountain, go now and
  speed well!"*
  ― J.R.R. Tolkien, The Hobbit


pkgId: 5bc62608ed1d9a5bafbc00d1ed74cc75d62be757288b37f609536542130d0af3
name: python-blackbelt
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Project automation the Apiary way
url: http://github.com/apiaryio/black-belt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blackbelt-0.16.0-1.src.rpm
checksum_type: sha256
description:
  Integrates useful GitHub workflow with Trello, Hipchat and Circle CI.
  Please visit `the Black Belt documentation <http://black-belt.readthedocs.org/en/latest/>`_ for more details.


pkgId: a397ffce0fdf5c330984890c830834c07ba28e8a05fd3464602a73f435911ed2
name: python-blackbirdCoOp
arch: src
version: 0.1.9
epoch: 0
release: 1
url: https://gitlab.igem.org/2024/software-tools/ucsc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-blackbirdCoOp-0.1.9-1.src.rpm
checksum_type: sha256
summary:
  A Stealth-based pipeline that optimizes inserts for cyanobacterial transformations in non-model organisms.

description:
  BLACKBIRD or BlackbirdCoOp is the software element for the 2024 UCSC iGem team, LIFT. BLACKBIRD is a software package that is able to optimize insert sequences for non-model cyanobacteria.



  BLACKBIRD is the software element of the 2024 UCSC iGem team, LIFT.

  BLACKBIRD is built on Stealth, a bioinformatics tool developed by our PI, David L. Bernick, at UCSC. Stealth identifies and reports statistically underrepresented k-mer motifs within a genome in order to identify potential restriction enzyme cut-sites within an insert's coding region. For software related information about Stealth, please refer to this [repository](https://git.ucsc.edu/dbernick/stealth).

  BLACKBIRD is a versatile program that uses the genomes of a host organism, the origin of the gene insert, and the genome of a target organism to optimize the gene insert which would be free of RM cut sites.

  *This is an alpha version which is a pre-release version whos successor aims to produce an optimized insert sequence that is even more efficient in eradicating the maximum number of stealth hits. Any BLACKBIRD results that have been produced and integrated into the project are a result of version 0 of BLACKBIRD.*

  For more information about the project and its goals, please refer to our [team wiki](https://2024.igem.wiki/ucsc/software)




  **For Unix/macOS:**

  First, check if your system can run python and the pip installer. Python packages that are not downloaded to your system need to be retrived by an installer like pip. Use the following prompts to check:
  ```bash
  usr:~$ python --version
  Python 3.x.x

  usr:~$ python3 --version
  Python 3.x.x

  usr:~$ python -m pip --version
  pip X.Y.Z from /<path>/<to>/<your>/pip (python 3.x.x)
  ```
  If you receive the following error, proceed to install python or pip on your system
  ```bash
  usr:~$ python3 --version
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'python3' is not defined
  ```



  If you do not have Python, get started by installing Python 3.10 or above from [python.org](https://www.python.org/downloads/), or through a distriubtion such as [anaconda](https://www.anaconda.com/download).

  If you do not have a working pip installer, follow steps found [here](https://pip.pypa.io/en/stable/installation/).



  Installing BlackbirdCoOp can be done by running the following command in your terminal with a valid pip installer to install the blackbirdCoOp package from the Python Package Index (PyPI):

  ```bash
  usr:~$ pip install blackbirdCoOp
  ```
  OR

  ```bash
  usr:~$ python -m pip install blackbirdCoOp
  ```

  **For Windows:**

  Windows requires a 'Path' environment in order to run the given CLI commands.

  First, confirm if you have the compatible python and pip environments on your system
  ```bash
  usr:~$ py --version
  Python 3.x.x

  usr:~$ py -m pip --version
  pip X.Y.Z from /<path>/<to>/<your>/pip (python 3.x.x)
  ```
  Download python and pip with the links above and follow the instruction for a Windows OS based install



  Installing BlackbirdCoOp can be done by running the following command in your terminal with a valid pip installer to install the blackbirdCoOp package from the Python Package Index (PyPI):

  ```bash
  usr:~$ python -m pip install blackbirdCoOp
  ```

  If you are unable to run the accompanying CLI commands, you need to set up a 'Path' environment with both Python and the 'Scripts' folder. Find the paths to both folders. Use the following command to find the location of BLACKBIRD:
  ```bash
  usr:~$ pip show blackbirdCoOp
  ```

  Follow the following commands to add to path via the GUI:
  _'Windows + X' -> 'System Properties' -> 'Advanced system settings' -> Environment variables -> System Variables_
  In this section, find the 'Path' and click 'Edit'. Now, click 'New' and add the following paths:
  ```bash
  C:\Users\YourUsername\AppData\Local\Programs\Python\PythonXX\
  C:\Users\YourUsername\AppData\Local\Programs\Python\PythonXX\Scripts\
  ```
  Replace 'PythonXX' with 'Python39' and save changes.





  Once installed, the main function can be easily run with the command `blackbirdcoop`
  ```bash

  blackbirdcoop --insert (-n) <insert infile> --stealth (-s) <stealth infile> --hostT (-ht) <host genome infile> --target (-t) <target genome infile> --outfile -o [outfile | default: stdout]
  ```

  The `blackbirdcoop` command takes 4 required arguments `--insert (-n)`, `--stealth (-s))`, `--hostT (-ht)`, and `--target (-t)`.
  `--insert (-n)` is the insert sequence of interest in Fasta format (.fa/.fasta)
  `--stealth (-s))` is the list of Stealth outputted kmers in a text file (.txt/.stealth)
  `--hostT (-ht)` is the host organism's codon usage table in TSV format (.tsv)
  `--target (-t)` is the target organism's complete genome in Fasta format (.fa/.fasta)

  An example of a insert sequence in Fasta format is as follows:
  ```bash
  >pET28:EGFP CDS
  ATGGTGAGCAAGGGCGAGGAGCTGTTCACCGGGGTGGTGCCCATCCTGGTCGAGCTGGACGGCGACGTAAACGGCCACAAGTTCAGCGTGTCCGGCGAGGGCGAGGGCGATGCCACCTACGGCAAGCTGACCCTGAAGTTCATCTGCACCACCGGCAAGCTGCCCGTGCCCTGGCCCACCCTCGTGACCACCCTGACCTACGGCGTGCAGTGCTTCAGCCGCTACCCCGACCACATGAAGCAGCACGACTTCTTCAAGTCCGCCATGCCCGAAGGCTACGTCCAGGAGCGCACCATCTTCTTCAAGGACGACGGCAACTACAAGACCCGCGCCGAGGTGAAGTTCGAGGGCGACACCCTGGTGAACCGCATCGAGCTGAAGGGCATCGACTTCAAGGAGGACGGCAACATCCTGGGGCACAAGCTGGAGTACAACTACAACAGCCACAACGTCTATATCATGGCCGACAAGCAGAAGAACGGCATCAAGGTGAACTTCAAGATCCGCCACAACATCGAGGACGGCAGCGTGCAGCTCGCCGACCACTACCAGCAGAACACCCCCATCGGCGACGGCCCCGTGCTGCTGCCCGACAACCACTACCTGAGCACCCAGTCCGCCCTGAGCAAAGACCCCAACGAGAAGCGCGATCACATGGTCCTGCTGGAGTTCGTGACCGCCGCCGGGATCACTCTCGGCATGGACGAGCTGTACAAGTAA
  ```
  A similar format can be applied to all input files in Fasta

  An example of the stealth input file is as follows:
  ```bash
  N = 3081514
  CGCG	[100]	RC Palindrome
  GCGC	[98]	RC Palindrome
  GGCC	[100]	RC Palindrome
  AATAG	[92]
  AATCG	[100] ...

  GAAGAC
  GTCTTC
  GGTCTC
  GAGACC
  ```
  The sequences starting on the second line are the generated under-represented k-mers. By default, the k-mers will be within the range of 4-8 nucleotides. 'RC Palindrome' refers to the occurence of palindromic under-represented sequences. The numbers in the bracket is usually higher than the thresholds/cut-off values set by the user. (Note: the version of stealth that handles bootstrapping will not be added to this repository at this time)

  The domestication protocol is also a very simple procedure. Simply add the known internal Type IIS restriction enzyme sites for Golden Gate Assembly at the end of the stealth file.

  An example of an organism's codon usage table in a tsv file is as follow:
  ```bash
  TTT	22.31	-2414783
  TTC	16.54	-1789835
  TTA	13.76	-1489606
  TTG	13.65	-1477363 ...
  ```
  In this version, BLACKBIRD considers the second values on each lines as the 'thousandths' value or the relative codon bias of each corresponding codon

  An example of the output file format is in a Fasta file as follows:
  ```bash
  >pET28:EGFP CDS output [8]
  ATGTCAATATATCAA...
  ```
  The number in the brackets refers to the current number of stealth hits of the outputted insert sequence



  The team is currently and will continue to better the algorithm in order to bring the number of stealth hits down to a minimum (ideally 0). All previous gene blocks corresponding to the most optimized results that the team has already been physically working with in order to attempt to demonstrate how the transformation efficiency was improved, were all based on the previous version.

  For the sake of demonstration purposes of the previous version, we have included documentation of one of our many target organisms at the time, PCC 11901's BLACKBIRD results (results which were already utilized to order gene blocks). This includes a complete genome file (as provided by [NCBI](https://www.ncbi.nlm.nih.gov/Taxonomy/Browser/wwwtax.cgi?id=2579791)), a GFP insert file (provided by [Addgene](https://www.addgene.org/browse/sequence/392768/)), an example of an open source [codon usage table of E. Coli](https://dnahive.fda.gov/dna.cgi?cmd=codon_usage&id=537&mode=cocoputs) (a recombinant host organism that is widely used to produce GFP) and a Stealth file containing a list of "stealth sites" or under-represented sites based on our PI David L. Bernick's software.

  As a result, there will also be documentation of an example of a simple Fasta file output containing the most optimized GFP sequence for the strain PCC11901.



  The LIFT, the 2024 UCSC iGem team consents to receiving any and all contributions offered.

  This software is published under the MIT license. Feel free to use any and all code provided by the project in any way and for any purpose.



  BLACKBIRD was written and contributed to by
  * Vibhitha Nandakumar (email: vinandak@ucsc.edu)
  * Aurko Mahesh (email: amahesh@ucsc.edu)

  Special thanks
  * David L. Bernick (email: dbernick@soe.ucsc.edu), our PI, allowing the further application of Stealth and for all the support and contributions throughout.
  * Robin Rounthwaite (email: rrounthw@ucsc.edu) for consultance in software architecture and Git repository management
  * TABI 2023 UCSC iGem team ([github](https://gitlab.igem.org/2023/software-tools/ucsc)) for support regarding Git repository management and project packaging
  * Reto Stamm (email: rstamm@ucsc.edu | [github](https://github.com/retospect)) for guidance in developing and publishing a package to the Python Package Index


