# packages

pkgId: 8f5122697e778d90c6114246e1c851fc65c37d8f7f5961656eed0d9a35c14659
name: python-balldontlie-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for balldontlie
url: https://pypi.org/project/balldontlie/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-balldontlie-0.1.4-1.src.rpm
location_href: Packages/python-balldontlie-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Official Python SDK for the BALLDONTLIE API. Access NBA, NFL, and MLB statistics and data. Check out the official website [here](https://app.balldontlie.io).



  ```bash

  pip install balldontlie


  pip install balldontlie==0.1.0
  ```



  ```python
  from balldontlie import BalldontlieAPI

  api = BalldontlieAPI(api_key="your-api-key")


  api.nba.teams.list()


  api.mlb.teams.list()


  api.nfl.teams.list()

  ```



  Check out the full API documentation:
  [NBA](https://nba.balldontlie.io)
  [NFL](https://nfl.balldontlie.io)
  [MLB](https://mlb.balldontlie.io)



  ```python
  from balldontlie import BalldontlieAPI
  from balldontlie.exceptions import (
      AuthenticationError,
      RateLimitError,
      ValidationError,
      NotFoundError,
      ServerError,
      BallDontLieException
  )

  client = BalldontlieAPI(api_key="your_key")

  try:
      teams = client.nba.teams.list()
  except AuthenticationError as e:
      print(f"Invalid API key. Status: {e.status_code}, Details: {e.response_data}")
  except RateLimitError as e:
      print(f"Rate limit exceeded. Status: {e.status_code}, Details: {e.response_data}")
  except ValidationError as e:
      print(f"Invalid request parameters. Status: {e.status_code}, Details: {e.response_data}")
  except NotFoundError as e:
      print(f"Resource not found. Status: {e.status_code}, Details: {e.response_data}")
  except ServerError as e:
      print(f"API server error. Status: {e.status_code}, Details: {e.response_data}")
  except BallDontLieException as e:
      print(f"General API error. Status: {e.status_code}, Details: {e.response_data}")
  except Exception as e:
      print(f"Unexpected error: {str(e)}")
  ```


pkgId: 228e3ecb888cff478e3f910ad5656096c666fb3876943869b9ac2103f73e4db3
name: python-bananopie-help
arch: noarch
version: 0.1.4.2
epoch: 0
release: 1
summary: Development documents and examples for bananopie
url: https://github.com/jetstream0/bananopie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bananopie-0.1.4.2-1.src.rpm
location_href: Packages/python-bananopie-help-0.1.4.2-1.noarch.rpm
checksum_type: sha256
description:
  Bananopie is a python library for the Banano cryptocurrency. It aims to be the python equivalent of Banano.js, and not just a RPC wrapper (Sending, receiving, changing rep functions are very high level).



  `pip install bananopie`

  Bananopie is on [pypi](https://pypi.org/project/bananopie/).


  - There is an outdated fork of Bananopie for Nano, also made by me, called [nanohakase](https://pypi.org/project/nanohakase/). It should suit most of your needs, but if you need new Bananopie features, fork Bananopie, change the work difficulty to `FFFFFFF800000000`, decimals to `31`, and you should be good to go.
  - When running on Replit (ew), installing Bananopie may fail if you do not have `gcc` installed (nix package: `libgccjit`).



  First, start with a `RPC` class, for read only
  ```py
  from bananopie import *
  rpc = RPC("https://kaliumapi.appditto.com/api")


  print(rpc.get_block_count()["count"])


  print(rpc.get_account_history("ban_1jung1eb3uomk1gsx7w6w7toqrikxm5pgn5wbsg5fpy96ckpdf6wmiuuzpca", count=10)["history"])


  print(raw_to_whole(int(rpc.get_account_balance("ban_1jung1eb3uomk1gsx7w6w7toqrikxm5pgn5wbsg5fpy96ckpdf6wmiuuzpca")["balance"])))
  ```

  For sending/receiving transactions, use a `Wallet`.
  ```py
  from bananopie import RPC, Wallet
  rpc = RPC("https://kaliumapi.appditto.com/api")

  my_account = Wallet(rpc, seed="seed here", index=0)


  my_new_account = Wallet(rpc, index=0)

  print(my_new_account.seed)


  print(my_account.get_address())


  print(my_account.get_balance())


  print(my_account.send("ban_3pdripjhteyymwjnaspc5nd96gyxgcdxcskiwwwoqxttnrncrxi974riid94", "1")["hash"])


  my_account.receive_all()


  my_account.change_rep("ban_3catgir1p6b1edo5trp7fdb8gsxx4y5ffshbphj73zzy5hu678rsry7srh8b")


  my_account.index = 2
  ```

  Bananopie can also generate work, albeit slowly. This is useful when using node that don't support generating work. Also, the `legacy` parameter can be passed to the RPC class when the RPC supports the deprecated `pending` RPC call instead of the newer `receivable` call.
  ```py
  from bananopie import RPC, Wallet

  no_work_rpc = RPC("https://public.node.jungletv.live/rpc", legacy=True)

  my_work_account = Wallet(no_work_rpc, seed="seed here", index=0, try_work=True)


  my_work_account.send("ban_3pdripjhteyymwjnaspc5nd96gyxgcdxcskiwwwoqxttnrncrxi974riid94", "0.0042")
  ```

  Utility functions are also provided.
  ```py
  import bananopie


  print(bananopie.whole_to_raw("492.2"))


  print(bananopie.raw_to_whole(1900000000000000000000000000))
  ```



  Also see the [Nano RPC docs](https://docs.nano.org/commands/rpc-protocol) for information on what rpc call wrapper functions return.


  **Parameters:**
  - `rpc_url` (*str*): IP or URL of node
  - `auth` (*str* or *bool*, Default: False): Optional HTTP Authorization header
  - `legacy` (*bool*, Default: False): If `True`, will use 'pending' instead of 'receivable'

  Sample:
  ```py
  rpc = RPC("https://kaliumapi.appditto.com/api")
  ```

  **Properties:**
  - `rpc_url` (*str*): IP or URL of node
  - `auth` (*str* or *bool*): Optional HTTP Authorization header

  **Methods:**


  RPC call. Intended for internal use, but useful for RPC calls that aren't directly implemented.

  **Parameters:**
  - `payload` (*dictionary*): Payload to send to node

  Sample:
  ```py
  rpc.call({"action": "block_count"})
  ```

  **Returns:**
  Response of RPC call (JSON dictionary)


  Get network block count.

  **Parameters**
  None

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#block_count)



  Get block info for hash.

  **Parameters**
  - `block` (*st*): Block hash

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#block_info)


  Get blocks.

  **Parameters**
  - `blocks` (*list[str]*): List of block hashes to get information on

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#blocks)


  Get blocks, with more detailed information.

  **Parameters**
  - `blocks` (*list[str]*): List of block hashes to get information on

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#blocks_info)


  Get list of network representatives and their weight

  **Parameters**
  None

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#representatives)


  Get list of network representatives that have recently voted

  **Parameters**
  None

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#representatives_online)


  Get account history (confirmed and received transaction list)

  **Parameters**
  - `account` (*str*): Address of account
  - `count` (*int*, Default: -1): Optional parameter to specify amount of transactions to return. `-1` means all, or at least as much as the node will allow
  - `head` (*str* or *None*, Default: None): Block hash to start from, defaults to latest block hash if omitted
  - `account_filter` (*list[str]* or *None*, Default: None): List of addresses to only show sends/receives from. Please note that some public nodes will ignore this parameter

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#account_history)


  Get account information, like height, frontier, balance, etc

  **Parameters**
  - `account` (*str*): Address of account

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#account_info)


  Get account balance

  **Parameters**
  - `account` (*str*): Address of account

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#account_balance)


  Get account representative

  **Parameters**
  - `account` (*str*): Address of account

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#account_representative)


  Get representatives of accounts

  **Parameters**
  - `account` (*list[str]*): List of addresses

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#account_representatives)


  Get delegated weight of representative

  **Parameters**
  - `account` (*str*): Address of representative

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#account_weight)


  Get receivable transactions for account

  **Parameters**
  - `account` (*str*): Address of representative
  - `count` (*int*, Default: 20): Optional parameter to specify max amount of receivable transactions to return
  - `threshold` (*int* or *None*, Default: None): Optional parameter to filter out any receivable transactions with value below the threshold (in raw)

  **Returns:**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#receivable)



  **Parameters:**
  - `rpc` (*RPC*): A RPC class
  - `seed` (*str* or *None*, Default: None): 64 character hex seed, if `None`, will generate a seed by itself. Private keys are derived from the seed.
  - `index` (*int*, Default: 0): Optional parameter that is the index of the seed. Any number from 0 to 4294967295. Each index of the seed is a different private key, and so different address.
  - `try_work` (*bool*, Default: False): If `True`, will try to generate work locally instead of asking node for work (and no work provided). Good to use if node does not support generating own work.

  Sample:
  ```py
  my_account = Wallet(RPC("https://kaliumapi.appditto.com/api"), "seed here", 0)
  ```

  **Properties:**
  - `rpc_url` (*str*): IP or URL of node
  - `seed` (*str*): Banano seed (64 character hex string)
  - `index` (*int*): Seed index. Change this property to change the wallet seed index.

  **Methods**


  Internal use function to send a `process` RPC call

  **Parameters**
  - `block` (*dictionary*): block content
  - `subtype` (*str*): Send, receive, or change

  **Returns**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#process)


  High level function to send Banano

  **Parameters**
  - `to` (*str*): Address to send to
  - `amount` (*str*): Amount of Banano to send (in whole, not raw)
  - `work` (*str* or *bool* or *function*, Default: False): Leave it as `False` to ask node to generate work (passes `do_work`). Put in a work string if work generated locally, if it is a function, the work will be the function called with the block hash as a parameter (keep in mind you can set the class' `try_work` to `True` to use the built-in `gen_work` function)
  - `previous` (*str* or *None*, Default: None): Previous block hash. Otherwise, address' frontier block hash used

  Sample:
  ```py
  my_account = Wallet(RPC("https://kaliumapi.appditto.com/api"), "seed here", 0)
  my_account.send("ban_3pdripjhteyymwjnaspc5nd96gyxgcdxcskiwwwoqxttnrncrxi974riid94", "1")
  ```

  **Returns**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#process)


  High level function to send all Banano

  **Parameters**
  - `to` (*str*): Address to send to
  - `work` (*str* or *bool* or *function*, Default: False): Leave it as `False` to ask node to generate work (passes `do_work`). Put in a work string if work generated locally, if it is a function, the work will be the function called with the block hash as a parameter (keep in mind you can set the class' `try_work` to `True` to use the built-in `gen_work` function)
  - `previous` (*str* or *None*, Default: None): Previous block hash. Otherwise, address' frontier block hash used

  Sample:
  ```py
  my_account = Wallet(RPC("https://kaliumapi.appditto.com/api"), "seed here", 0)
  my_account.send_all("ban_3pdripjhteyymwjnaspc5nd96gyxgcdxcskiwwwoqxttnrncrxi974riid94")
  ```

  **Returns**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#process)


  Receive a specific block

  **Parameters**
  - `hash` (*str*): Block hash to receive
  - `work` (*str* or *bool* or *function*, Default: False): Leave it as `False` to ask node to generate work (passes `do_work`). Put in a work string if work generated locally, if it is a function, the work will be the function called with the block hash as a parameter (keep in mind you can set the class' `try_work` to `True` to use the built-in `gen_work` function)
  - `previous` (*str* or *None*, Default: None): Previous block hash. Otherwise, address' frontier block hash used

  **Returns**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#process)


  Receive all (technically, 20) receivable transactions

  **Parameters**
  - `count` (*int*, Default: 20): Optional parameter to specify max amount of receivable transactions to receive
  - `threshold` (*int* or *None*, Default: None): Optional parameter to not receive any receivable transactions with value below the threshold (in whole, not raw)
  - `work` (*bool* or *function*, Default: False): Leave it as `False` to ask node to generate work (passes `do_work`). If it is a function, the work will be the function called with the block hash as a parameter (keep in mind you can set the class' `try_work` to `True` to use the built-in `gen_work` function)

  Sample:
  ```py
  my_account = Wallet(RPC("https://kaliumapi.appditto.com/api"), "seed here", 0)
  my_account.receive_all()
  ```

  **Returns**
  - A list of block hashes that were received (See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#process))


  Change account representative

  **Parameters**
  - `new_representative` (*str*): Representative Banano address to change to
  - `work` (*str* or *bool* or *function*, Default: False): Leave it as `False` to ask node to generate work (passes `do_work`). Put in a work string if work generated locally, if it is a function, the work will be the function called with the block hash as a parameter (keep in mind you can set the class' `try_work` to `True` to use the built-in `gen_work` function)
  - `previous` (*str* or *None*, Default: None): Previous block hash. Otherwise, address' frontier block hash used

  Sample:
  ```py
  my_account = Wallet(RPC("https://kaliumapi.appditto.com/api"), "seed here", 0)
  my_account.change_rep("ban_3catgir1p6b1edo5trp7fdb8gsxx4y5ffshbphj73zzy5hu678rsry7srh8b")
  ```

  **Returns**
  See [Nano RPC Docs](https://docs.nano.org/commands/rpc-protocol/#process)


  Sign utf-8 message with private key at current index of current seed

  **Parameters**
  - `message` (*str*): utf-8 message to sign

  **Returns**
  *str*, Hex signature


  Sign utf-8 message as a dummy block (making sure ledger devices can also sign) with private key at current index of current seed

  **Parameters**
  - `message` (*str*): utf-8 message to sign

  **Returns**
  *str*, Hex signature


  Get public key at current index of current seed

  **Parameters**
  None

  **Returns**
  *str*, Hex public key


  Get address at current index of current seed

  **Parameters**
  None

  **Returns**
  *str*, Banano address


  Double wrapped function to get balance of self (see `RPC`'s `get_account_balance`)


  Double wrapped function to get receivable blocks (see `RPC`'s `get_receivable`)


  Double wrapped function to get receivable blocks (see `RPC`'s `get_receivable`), except `threshold` parameter is in whole Banano, not raw


  Double wrapped function to get representative of self (see `RPC`'s `get_account_representative`)


  Double wrapped function to get account info of self (see `RPC`'s `get_account_info`)


  Double wrapped function to get account info of self (see `RPC`'s `get_account_history`)


  Generate a random seed using `os.urandom`

  **Parameters**
  None

  Sample:
  ```py
  print(Wallet.generate_seed())
  ```

  **Returns**
  64 character hex seed



  **Properties**
  - `BANANO_DECIMALS` (*int*): Amount of decimals that Banano has (29)
  - `PREAMBLE` (*str*): Hex string to prepend when signing
  - `BANANO_WORK` (*str*): Hex string of Banano's work threshold/minimum

  **Methods**

  `encode_base32`, `decode_base32`, `bytes_to_hex`, `hex_to_bytes`, `utf8_to_bytes`, `random_bytes`, `get_private_key_from_seed`, `get_public_key_from_private_key`, `get_address_from_public_key`, `get_public_key_from_address`, `hash_block`, `sign`, `sign_message_dummy_block`, `gen_dummy_block_hash` are internal use Functions that are currently undocumented. Look at `/bananopie/util.py` to see what they do.


  Verifies whether signed message is real

  **Parameters**
  - `public_key` (*str*): Hex public key
  - `signature` (*str*): Hex signature
  - `claimed_message` (*str*): utf-8 message that was allegedly signed

  **Returns**
  *bool*, `True` if message verified, `False` if message not verified


  Verifies whether signed message (with dummy block) is real

  **Parameters**
  - `public_key` (*str*): Hex public key
  - `signature` (*str*): Hex signature
  - `claimed_message` (*str*): utf-8 message (with dummy block) that was allegedly signed

  **Returns**
  *bool*, `True` if message (with dummy block) verified, `False` if message (with dummy block) not verified


  Converts whole Banano to raw Banano

  **Parameters**
  - `whole` (*str*): Whole amount of Banano

  **Returns**
  *int*, that is raw amount of Banano


  Converts raw Banano to whole Banano (Cuts off at 2 decimal places by default)

  **Parameters**
  - `raw` (*int*): Raw amount of Banano
  - `precision` (*int*, Default: 2): Decimal places to cut off at

  **Returns**
  *int*, that is whole amount of Banano


  Converts raw Banano to whole Banano, without rounding

  **Parameters**
  - `raw` (*int*): Raw amount of Banano

  **Returns**
  *str*, that is unrounded whole amount of Banano


  Generate work given block's previous hash (or if opening block, account public key), and threshold. Generates work using psuedorandom generator.

  **Parameters**
  - `hash` (*str*): Hex previous hash of block / account public key
  - `threshold` (*str*): Hex minimum work threshold

  **Returns**
  *str*, that is hex of work


  Generate work given block's previous hash (or if opening block, account public key), and threshold. Generates work deterministically.

  **Parameters**
  - `hash` (*str*): Hex previous hash of block / account public key
  - `threshold` (*str*): Hex minimum work threshold

  **Returns**
  *str*, that is hex of work


  Generate work given block's previous hash (or if opening block, account public key). Basically a wrapper for `gen_work_deterministic` with threshold being the hardcoded Banano default.

  **Parameters**
  - `hash` (*str*): Hex previous hash of block / account public key

  **Returns**
  *str*, that is hex of work


  Verify whether work is valid or not, given previous hash of block (or if opening block, account public key).

  **Parameters**
  - `hash` (*str*): Hex previous hash of block / account public key
  - `work` (*str*): Hex of work

  **Returns**
  *bool*, whether the work is valid or not


pkgId: b37ec17e805e175ee843969b95886dac0585d733deac7cf5c3a8e4cf05693529
name: python-banff-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for banff
url: https://pypi.org/project/banff/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-banff-0.0.0-1.src.rpm
location_href: Packages/python-banff-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Banff is a package developed by Statistics Canada, consisting of nine modular procedures performing various statistical data editing (SDE) functions:

  * Verify Edits: Checks the edits for consistency and redundancy.
  * Edit Statistics: Produces edit summary statistics tables on records that pass, miss or fail each consistency edit
  * Outlier Detection: Identifies outlying observations using Hidiroglou-Berthelot or Sigma-Gap methods.
  * Error Localization: For each record, selects the minimum number of variables to impute such that each observation can be made to pass all edits.
  * Deterministic Imputation: Performs imputation when only one combination of values permits the record to pass the set of edits.
  * Donor Imputation: Performs nearest neighbour donor imputation such that each imputed record satisfies the specified post-imputation edits.
  * Estimator Imputation: Performs imputation using estimation functions or linear regression estimators.
  * Prorating: Prorates and rounds records to satisfy user-specified edits.
  * Mass Imputation: Performs donor imputation for a block of variables using a nearest neighbour approach or random selection.

  Some general notes about Banff:

  * Most of the SDE methods included in Banff are designed for economic surveys, and in particular numerical variables such as revenue and employee counts. Banff does not currently include methods recommended for the imputation of categorical or ordinal data.
  * Banff includes a number of methods designed for data whose variables are constrained by linear relationships, also commonly referred to as linear edit rules or simply edits. This includes procedures that review data with respect to the edits, choose which variables to impute when the edits fail, and impute records to ensure that all edits are satisfied.
  * While each Banff procedure can be run independently, they follow a modular template and can be run in sequence as part of a larger SDE process flow. Outputs from one procedure act as natural inputs for subsequent procedures.
  * Banff uses status flags to track metadata such as selection and imputation flags. These status flags allow the Banff procedures to pass information from one procedure to another, and also serve as a log of the overall SDE process.

  When running Banff procedures in sequence as part of an SDE process flow, users are responsible for input and output between steps. An additional package, the **Banff Processor**, is a metadata-driven utility designed specifically for large-scale SDE production, incorporating the Banff procedures, and handling all intermediate data management.

  The Banff user guide often uses terminology from the [**Generic Statistical Data Editing Model** (GSDEM)](https://statswiki.unece.org/spaces/sde/pages/117771706/GSDEM). Users are encouraged to reference the GSDEM for common terminology regarding SDE concepts.


pkgId: f8b500b89bd94387cd4ccdcabe8a7449a11008adb90c35ff5c70249daae9d4d0
name: python-banffprocessor-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for banffprocessor
url: https://pypi.org/project/banffprocessor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-banffprocessor-0.0.0-1.src.rpm
location_href: Packages/python-banffprocessor-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  The Banff Processor is part of the Banff project. It is a tool that can be installed in addition to the Banff Procedure package. This tool is used to implement an imputation strategy, which is essentially a sequence of processing steps. A processing step can be a standard Banff Procedure, a user-defined process (plugin) or a process block (another sequence of processing steps).

  Imputation strategies are defined using XML files, an Excel template has been provided along with a utility to convert metadata created with the template to the XML files required by the processor. The output of a processor job is the imputed file along with a log and various status and optional diagnostic files.



  The Banff Processor was originally written in SAS 9 using the SAS macro language. In 2023-24, the Banff Processor was redeveloped as a python package and released as version 2. New features were added such as Process Controls and Process Blocks.


pkgId: f66b1d26d818cb054f00d6c1ef37e9fb624a43f0b5e0c546d538ba4f219ac7a9
name: python-bangla-dictionary-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for bangla-dictionary
url: https://github.com/bipsec/bangla-dictionary
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bangla-dictionary-0.0.3-1.src.rpm
location_href: Packages/python-bangla-dictionary-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  BanglaDictionary is a Python package that provides a dictionary for the Bengali (Bangla) language. It allows you to retrieve meanings, pronunciations, examples, parts of speech, types, and sources of words in the Bengali language.
  Also It is a package that allows to build dictionary from Bangla and all other contents from a Bangla dictionary. It allows user how to create online dictionary from scratch and use it to other language'



  You can install the BanglaDictionary package using pip:

  ```shell
  pip install bangla-dictionary
  ```


  ```sh
  bangla_dictionary/
  ├── bangla_dictionary/
  │   ├── __init__.py
  │   ├── dictionary.py
  ├── data/
  │   │   ├── bangla_dictionary_pkl
  ├── scripts/
  │   │   ├── preprocess.py
  │   │   ├── read_pickle.py
  │   │   ├── words.py
  │   │   ├── write_pickle.py
  │   ├── tests/
  │   │   ├── __init__.py
  │   │   ├── test_config.py
  │   │   ├── test_dict.py
  │   │   ├── test_runner.py
  │   │   ├── test_suite.py
  ├── word_details/
  │   ├── banglaWords.txt
  ├── __init__.py
  ├── .gitignore
  ├── LICENSE
  ├── setup.py
  ├── README.md
  └── requirements.txt
  ├── todo.txt
  ```






  Here's an example of how to use the BanglaDictionary package:

  ```python

  from bangla_dictionary.dictionary import BanglaDictionary
  bd = BanglaDictionary()


  meaning = bd.get_meaning("অই")
  print(meaning)  # Output: {"২": ["পদ্যে ছন্দের খাতিরে নির্দেশক স্বরবর্ণ 'ঐ' কখনো কখনো 'অই' রুপে ব্যবহৃত হয়", "স্মরণ সম্বোধন ও আক্ষেপাদি সূচক"], "১": ["অদূরে বা সম্মুখবর্তী কোনো কিছু নির্দেশে ", "নির্দিষ্ট", "উল্লিখিত", "সেই"]}


  pronunciation = bd.get_pronunciation("অংগুষ্ঠানা")
  print(pronunciation)  # Output: "ওঙ্গুশঠানা"


  example = bd.get_example("অকাজ")
  print(example)  # Output: "সে হলো অকাজের কাজী।"


  pos = bd.get_pos("অকাট্য")
  print(pos)  # Output: "বিণ"


  word_type = bd.get_type("অঋণ")
  print(word_type)  # Output: "অর্থ [অর্থনৈতিক]"


  source = bd.get_source("অকাণ্ড")
  print(source)  # Output: "ব্যবহারিক বাংলা অভিধান"

  ```

  ```python

  from bangla_dictionary.dictionary import BanglaDictionary
  bd = BanglaDictionary()

  meanings = bd.get_multiple_meanings("অংশভাগী", "অংশল", "অংশহারী")
  print(meanings)  # Output: {'অংশভাগী': '{"১": ["অংশ পাওয়ার যোগ্য", "অংশীদার"]}', 'অংশল': '{"১": ["বলবান", "বলশালী"]}', 'অংশহারী': '{"১": ["অংশলোপ", "অপহরণ করে এমন"], "২": ["অংশগ্রহণকারী"]}'}


  pronunciations = bd.get_multiple_pronunciations("অংশহারী", "অংশাংশ", "অংশানো")
  print(pronunciations)  # Output: {"অংশহারী": "অঙ্‌শোহর", "অংশাংশ": "অঙ্‌শাঙ্‌শো", "অংশানো": "অঙ্‌শানো"}


  examples = bd.get_multiple_examples("অকল্যান", "অকষ্টবদ্ধ", "অকস্মাৎ")
  print(examples)  # Output: {"অকল্যান": "অকল্যান এই সুর।", "অকষ্টবদ্ধ": "সাধু বাংলার বাক্য গঠন পদ্ধতি অকষ্টবদ্ধ।", "অকস্মাৎ": "ছেড়েছি সব অকস্মাতের আশা।"}


  pos_list = bd.get_multiple_pos("অকল্যাণকর", "অকল্মষ", "অকস্মাৎ")
  print(pos_list)  # Output: {"অকল্যাণকর": "বিণ", "অকল্মষ": "বিণ", "অকস্মাৎ": "ক্রিবিন"}


  types = bd.get_multiple_types("অকরোটি ", "অঋণী", "অইরান")
  print(types)  # Output: {"অকরোটি ": "প্রাণি [প্রাণিবিজ্ঞান]", "অঋণী": "অর্থ [অর্থনৈতিক]", "অইরান": "ফা. [ফারসি]"}


  sources = bd.get_multiple_sources("অকরোটি", "অঋণী", "অইরান")
  print(sources)  # Output: {"অকরোটি": "ব্যবহারিক বাংলা অভিধান", "অঋণী": "ব্যবহারিক বাংলা অভিধান", "অইরান": "ব্যবহারিক বাংলা অভিধান"}
  ```




  The data used by the BanglaDictionary package is sourced from Bangla Dictionary: Bangla Academy- ব্যবহারিক বাংলা অভিধান. The dictionary provides meanings, pronunciations, examples, parts of speech, types, and sources for a wide range of Bengali words.


  If you find any issues or would like to contribute to the BanglaDictionary package, please feel free to open an issue or submit a pull request on the GitHub repository. Feel free to create issues to contact.



  The BanglaDictionary package is released under the MIT License. You are free to use, modify, and distribute this package in your own projects.


pkgId: bb59f44e4b1c5a9760ac972ec4645c6da944336ce66e25c6622070b54d586299
name: python-bangla-dictionary-help
arch: noarch
version: 0.4
epoch: 0
release: 1
summary: Development documents and examples for bangla-dictionary
url: https://github.com/bipsec/bangla-dictionary
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bangla-dictionary-0.4-1.src.rpm
location_href: Packages/python-bangla-dictionary-help-0.4-1.noarch.rpm
checksum_type: sha256
description:
  BanglaDictionary is a Python package that provides a dictionary for the Bengali (Bangla) language. It allows you to retrieve meanings, pronunciations, examples, parts of speech, types, and sources of words in the Bengali language.
  Also, It is a package that allows to build dictionary from Bangla and all other contents from a Bangla dictionary. It allows user how to create online dictionary from scratch and use it to other language'



  You can install the BanglaDictionary package using pip:

  ```shell
  pip install bangla-dictionary
  ```


  ```sh
  bangla_dictionary/
  ├── bangla_dictionary/
  │   ├── __init__.py
  │   ├── dictionary.py
  ├── data/
  │   ├── __init__.py
  │   ├── bangla_dictionary_pkl
  ├── scripts/
  │   ├── __init__.py
  │   ├── preprocess.py
  │   ├── read_pickle.py
  │   ├── words.py
  │   ├── write_pickle.py
  ├── tests/
  │   ├── __init__.py
  │   ├── test_config.py
  │   ├── test_dict.py
  │   ├── test_runner.py
  │   ├── test_suite.py
  ├── word_details/
  │   ├── banglaWords.txt
  ├── __init__.py
  ├── .gitignore
  ├── LICENSE
  ├── setup.py
  ├── README.md
  └── requirements.txt
  ```




  Here's an example of how to use the BanglaDictionary package:

  ```python

  from bangla_dictionary.dictionary import BanglaDictionary

  bd = BanglaDictionary()


  meaning = bd.get_meaning("অই")
  print(meaning)  # Output: {"২": ["পদ্যে ছন্দের খাতিরে নির্দেশক স্বরবর্ণ 'ঐ' কখনো কখনো 'অই' রুপে ব্যবহৃত হয়", "স্মরণ সম্বোধন ও আক্ষেপাদি সূচক"], "১": ["অদূরে বা সম্মুখবর্তী কোনো কিছু নির্দেশে ", "নির্দিষ্ট", "উল্লিখিত", "সেই"]}


  pronunciation = bd.get_pronunciation("অংগুষ্ঠানা")
  print(pronunciation)  # Output: "ওঙ্গুশঠানা"


  example = bd.get_example("অকাজ")
  print(example)  # Output: "সে হলো অকাজের কাজী।"


  pos = bd.get_pos("অকাট্য")
  print(pos)  # Output: "বিণ"


  word_type = bd.get_type("অঋণ")
  print(word_type)  # Output: "অর্থ [অর্থনৈতিক]"


  source = bd.get_source("অকাণ্ড")
  print(source)  # Output: "ব্যবহারিক বাংলা অভিধান"

  ```

  ```python

  from bangla_dictionary.dictionary import BanglaDictionary

  bd = BanglaDictionary()

  meanings = bd.get_multiple_meanings("অংশভাগী", "অংশল", "অংশহারী")
  print(meanings)  # Output: {'অংশভাগী': '{"১": ["অংশ পাওয়ার যোগ্য", "অংশীদার"]}', 'অংশল': '{"১": ["বলবান", "বলশালী"]}', 'অংশহারী': '{"১": ["অংশলোপ", "অপহরণ করে এমন"], "২": ["অংশগ্রহণকারী"]}'}


  pronunciations = bd.get_multiple_pronunciations("অংশহারী", "অংশাংশ", "অংশানো")
  print(pronunciations)  # Output: {"অংশহারী": "অঙ্‌শোহর", "অংশাংশ": "অঙ্‌শাঙ্‌শো", "অংশানো": "অঙ্‌শানো"}


  examples = bd.get_multiple_examples("অকল্যান", "অকষ্টবদ্ধ", "অকস্মাৎ")
  print(
      examples)  # Output: {"অকল্যান": "অকল্যান এই সুর।", "অকষ্টবদ্ধ": "সাধু বাংলার বাক্য গঠন পদ্ধতি অকষ্টবদ্ধ।", "অকস্মাৎ": "ছেড়েছি সব অকস্মাতের আশা।"}


  pos_list = bd.get_multiple_pos("অকল্যাণকর", "অকল্মষ", "অকস্মাৎ")
  print(pos_list)  # Output: {"অকল্যাণকর": "বিণ", "অকল্মষ": "বিণ", "অকস্মাৎ": "ক্রিবিন"}


  types = bd.get_multiple_types("অকরোটি ", "অঋণী", "অইরান")
  print(types)  # Output: {"অকরোটি ": "প্রাণি [প্রাণিবিজ্ঞান]", "অঋণী": "অর্থ [অর্থনৈতিক]", "অইরান": "ফা. [ফারসি]"}


  sources = bd.get_multiple_sources("অকরোটি", "অঋণী", "অইরান")
  print(
      sources)  # Output: {"অকরোটি": "ব্যবহারিক বাংলা অভিধান", "অঋণী": "ব্যবহারিক বাংলা অভিধান", "অইরান": "ব্যবহারিক বাংলা অভিধান"}
  ```




  The data used by the BanglaDictionary package is sourced from Bangla Dictionary: Bangla Academy- ব্যবহারিক বাংলা অভিধান. The dictionary provides meanings, pronunciations, examples, parts of speech, types, and sources for a wide range of Bengali words.


  If you find any issues or would like to contribute to the BanglaDictionary package, please feel free to open an issue or submit a pull request on the GitHub repository. Feel free to create issues to contact.



  The BanglaDictionary package is released under the MIT License. You are free to use, modify, and distribute this package in your own projects.


pkgId: 176544b6ee8c3e87224322340e527598a13ece9635572156e2ed06ffce8e5811
name: python-bangla-ipa-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for bangla-ipa
url: https://github.com/bipsec/IPA-PyPI
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bangla-ipa-0.1-1.src.rpm
location_href: Packages/python-bangla-ipa-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  BanglaToIPA is a Python package designed to transcribe Bengali words into the International Phonetic Alphabet (IPA). This tool simplifies the pronunciation of Bengali words, making it easier for people worldwide who are familiar with IPA to accurately pronounce them.


  You can install the BanglaToIPA package using pip:

  ```shell
  pip install bangla-ipa
  ```


  ```sh
  IPA/
  ├── ipa/
  │   ├── __init__.py
  │   ├── ipa.py
  ├── model/
  │   ├── ipa_model.pth
  ├── data/
  │   │   ├── ipa_vocab_data
  ├── script/
  │   │   ├── __init__.py
  │   │   ├── translator.py
  ├── tests/
  │   │   ├── __init__.py
  │   │   ├── test_bangla_ipa.py
  ├── __init__.py
  ├── .gitignore
  ├── LICENSE
  ├── setup.py
  ├── README.md
  └── requirements.txt
  ```




  Here's an example of how to use the BanglaDictionary package:

  ```python

  from ipa.ipa import BanglaIPATranslator
  ipa = BanglaIPATranslator()


  translated_ipa = ipa.translate("মহারাজ") # Output: "mɔharaɟ"
  ```



  The data used by the BanglaToIPA package is sourced from private annotated corpus for bengali letters and their appropriate form of IPA. It is carefully curated and validated from multiple resources before training and generating the model for transcribing IPA for bengali words.


  If you find any issues or would like to contribute to the BanglaToIPA package, please feel free to open an issue or submit a pull request on the GitHub repository. Feel free to create issues to contact.



  The BanglaToIPA package is released under the MIT License. You are free to use, modify, and distribute this package in your own projects.


pkgId: d484b84939441efc7084a721192fff2eda3372650ea29e8eb20725f71e50f452
name: python-bannerpy-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for bannerpy
url: https://pypi.org/project/bannerpy/
rpm_license: GPL v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bannerpy-0.1.0-1.src.rpm
location_href: Packages/python-bannerpy-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  color_type:
  fonts:
    dejavusans: /path/to/fonts/DejaVuSans.ttf
    silvertones: /path/to/fonts/Silvertones.ttf
  bg_color: "#ffffff"
  border_radius: 50
  margin_x: 15
  margin_y: 20
  resolution:
    - 1920
    - 1080
  auto_height: true
  fields:
    name:
      type: text
      font: silvertones
      font_size: 200
      font_color: "#2b361b"
      h_align: center
      v_align: top # or middle or bottom
      margin_x: 0
      margin_y: 0
      variable: true
    divider:
      type: image
      value: /path/to/long-squiggle.png
      
      margin_x: 0
      margin_y: 15
      variable: false
    title:
      type: text
      font: dejavusans
      font_size: 100
      font_color: "#191515"
      h_align: center
      variable: true
    organization:
      type: text
      font: dejavusans
      font_size: 70
      font_color: "#191515"
      h_align: center
      variable: true
  ```
  </details>

  ![citation](example/simple_with_underline.png)
  <details><summary>Code</summary>
  Python
  ```python
  test_card = cards.Card('example/simple_with_underline.png', margin_x = 8, margin_y = 15, border_radius = 100)
  title = fields.TextField('(Groth et al., 2011)', fonts['dejavusans'], 130, margin_y = 5, h_align=pixie.CENTER_ALIGN)
  underline = fields.Image('example/short-squiggle.png', margin_x = 20, margin_y = 20)
  test_card.fields = [title, underline]
  test_card.render()
  ```
  </details>

  ![heading](example/simple_heading.png)
  <details><summary>Code</summary>
  Python
  ```python
  test_card = cards.Card('example/simple_heading.png', bg_color=(0.235, 0.549, 0.255, 0.9), border_radius = 125, margin_y = 25)
  heading = fields.TextField('Part 1', '/path/to/fonts/GROBOLD.ttf', 150, font_color = (0, 0, 0, 0.7), h_align=pixie.CENTER_ALIGN)
  subheading = fields.TextField('Introduction', '/path/to/fonts/DejaVuSans.ttf', 100, font_color = (0, 0, 0, 0.7), h_align=pixie.CENTER_ALIGN)
  test_card.append(heading)
  test_card.append(subheading)
  test_card.render()
  ```
  </details>

  ![disclaimer](example/simple.png)
  <details><summary>Code</summary>
  Python
  ```python
  test_card = cards.Card('example/simple.png', margin_x=5, margin_y=35, border_radius=20, bg_color=(0.4, 0.1, 0.2, 0.8))
  body = fields.TextField('These results are not definitive. Further research is necessary to determine definitive results.', '/path/to/fonts/DejaVuSans.ttf', 30, font_color=(0, 0, 0, 0.6))
  test_card.fields = [body]
  test_card.render()
  ```
  </details>

  BannerPy has 4 main parts:
  - [Card class](#Card-class)
  - [TemplateCard class](#TemplateCard-class)
  - `TextField` class
  - `Image` class

  The `Card` class is the heart of BannerPy. It takes parameters, a list of `Field` objects, and then generates the card image with the `render()` method

  - `filename` (str): Path to the output file
  - `bg_color` (tuple): Tuple (R, G, B, A) to represent the background color (Detault: `(1, 1, 1, 1)`)
  - `border_radius` (int): Integer number for the radius (px) of the rounded corners of the card (Default: `0`)
  - `margin` (int): Shorthand to set margin x and margin y to the same
  - `margin_x` (int): Percentage for x margin for the content area (Default: `10`)
  - `margin_y` (int): Percentage for y margin for the content area (Default: `20`)
  - `resolution` (tuple): The resolution of the card (Default: `(1920, 1080)`)
  - `fields` (list[Field]): A list of Fields to populate the card. (Default: `[]`)
  - `auto_height` (bool): Whether to automatically determine the height of the card (Default: `True`)

  Setter and getter methods are excluded, as well as internal methods
  - `auto_height()`: Calculate the y resolution of the card based on the contents of `fields`. This is automatically run when `auto_height` is enabled at initialization
  - `append(field: Field)`: Append a Field (TextField, Image) object to the card's `fields` property
  - `render()`: Render the image

  The TemplateCard class is based on the Card class. It takes in a path to a yaml file and loads those settings. In addition to the template config, you also need to provide the `filename` and the values to fill in the template

  - `template` (str): Path to the YAML file to load
  - `filename` (str): Path to the output file
  - `**kwargs`: Arguments that match the variables in your template file. For example, if you have a `body_text` field in your template, kwargs would include `body_text = "text value"`

  Same as `Card` class

  Below is the outline of a YAML template, with notes
  <details><summary>YAML template specification</summary>
  Notes:
  - For text fields, you *can* use the `font_path` argument instead of `font`. `font` is supported as a convenience for reusing fonts across different fields.
  - All string fields are case insensitive
  - Hex colors do not support transparency. They must be 6-digit hex codes.


pkgId: f8d8f8b1be307864bcea3b73b64d664f3db6f2073c586cf893440fb0ae2359df
name: python-bar-gmail-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for bar-gmail
url: https://github.com/crabvk/bar-gmail
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bar-gmail-1.0.6-1.src.rpm
location_href: Packages/python-bar-gmail-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  ![preview](https://github.com/crabvk/polybar-gmail/raw/master/preview.png)

  Get notifications and unread messages count from Gmail (Waybar/Polybar module).



  * Font Awesome: default badge 
  * Libcanberra: notification sound (optional).

  To display notifications you must have a [notification daemon](https://wiki.archlinux.org/title/Desktop_notifications#Notification_servers) running on your system.



  Use one of the following methods.



  https://aur.archlinux.org/packages/bar-gmail/



  ```sh
  pip install --user bar-gmail
  ~/.local/bin/bar-gmail
  ```

  Depending on your system you may also need to add the `--break-system-packages` flag.



  ```sh
  git clone https://github.com/crabvk/bar-gmail.git
  cd bar-gmail
  git describe --abbrev=0 --tags # Get latest tag.
  git checkoug LATEST_TAG
  pip install -e .
  ~/.local/bin/bar-gmail
  ```



  First, you need to authenticate the client:

  ```sh
  bar-gmail auth
  ```

  Then just run `bar-gmail` or `bar-gmail --format polybar` periodically to get unread messages count and new message notifications.

  Credentials and session are stored in *~/.cache/bar-gmail*.



  *~/.config/waybar/config*

  ```json
  "modules-right": {
      "custom/gmail"
  }

  "custom/gmail": {
      "exec": "bar-gmail",
      "return-type": "json",
      "interval": 10,
      "tooltip": false,
      "on-click": "xdg-open https://mail.google.com/mail/u/0/#inbox"
  }
  ```

  *~/.config/waybar/style.css*

  ```css

      color: white;
  }

      color: darkorange;
  }

      color: darkred;
  }
  ```



  ```ini
  modules-right = gmail
  ...
  [module/gmail]
  type = custom/script
  exec = bar-gmail -f polybar
  interval = 10
  click-left = xdg-open https://mail.google.com/mail/u/0/#inbox
  ```



  See `bar-gmail --help` for the full list of available subcommands and command arguments.

  Possible values for `-s`, `--sound` is obtained with:

  ```shell
  ls /usr/share/sounds/freedesktop/stereo/ | cut -d. -f1
  ```

  for example `bar-gmail --sound message-new-instant`.

  If you have several mails you can specify the `credentials.json` file with the `--credentials <path>` flag.


pkgId: 491d8ed9c3ff61624e1697002caa19e3a353304ef0f71954791350a260d7586f
name: python-bareos-restapi-help
arch: noarch
version: 24.0.0
epoch: 0
release: 1
summary: Development documents and examples for bareos-restapi
url: https://github.com/bareos/bareos/
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bareos-restapi-24.0.0-1.src.rpm
location_href: Packages/python-bareos-restapi-help-24.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Experimental and subject to enhancements and changes.

  This is an experimental backend for development purposes.

  It provides a REST API using fastapi and python-bareos to connect to
  a Bareos director.

  * https://fastapi.tiangolo.com/
  * https://www.openapis.org/





  We recommend to create a dedicated Python environment for the installation in an own directory:

  ```
  python3 -m venv env

  source env/bin/activate

  pip install bareos-restapi
  ```

  Note: The optional module _sslpsk_ can be installed manually, if you want encrypted communication between the API and the Bareos director.



  The module directory contains a sample ini-file. Change into this directory (something like */lib/python3.x/site-packages/bareosRestapiModels* on most operating systems) and copy _api.ini.sample_ to _api.ini_ and adapt it to your director. Make sure to generate an own secret-key for the _JWT_ section.

  Your director configuration in _api.ini_ should look like:
  ```
  [Director]
  Name=bareos-dir
  Address=127.0.0.1
  Port=9101
  ```

  Note: you will need a *named console* (user/password) to acces the Bareos director using this API. Read more about Consoles here:
  https://docs.bareos.org/Configuration/Director.html#console-resource




  From inside the module directory run:

  ```
  uvicorn bareos-restapi:app --reload
  ```

  * Serve the Swagger UI to explore the REST API: http://127.0.0.1:8000/docs
  * Alternatively you can use the redoc format: http://127.0.0.1:8000/redoc



  The Swagger UI contains documentation and online-tests. Use "authorize" to connect to your Bareos director using a named console. Read here to learn how to configure
  a named console: https://docs.bareos.org/Configuration/Director.html#console-resource

  The Swagger documentation also contains CURL statements for all available endpoints.



  The API will be extended by some methods provided by the Bareos console, that are not yet implemented. It is also planned to add delete / update options for configuration in the director and REST API. If you are interested in support and / or funding enhancements, please visit https://www.bareos.com

  TODO:
  - define and document response model
  - add possibility to connect to a choice of directors
  - add start-script with ini-file name as parameter


pkgId: 9f542500f6ab70ea1c38ffd76a151c1eea75e40d203d426394a0e15ddc4582da
name: python-basalam.backbone-api-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for basalam.backbone-api
url: https://github.com/basalam/backbone-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-basalam.backbone-api-0.1.1-1.src.rpm
location_href: Packages/python-basalam.backbone-api-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  OpenAPI request and response models



  ```shell
  pip install basalam.backbone-api
  ```


  - [ ] Add Message Toast Field
  - [ ] Add Pagination Query Params Dependency



  ```python
  import uvicorn
  from fastapi import APIRouter
  from fastapi import FastAPI
  from pydantic import BaseModel

  from basalam.backbone_api.responses import (
      ForbiddenResponse,
      NotFoundResponse,
      UnauthorizedResponse,
      UnprocessableContentResponse,
      BulkResponse, ConflictResponse
  )

  app = FastAPI()


  class User(BaseModel):
      id: int
      name: str


  router = APIRouter(responses={
      401: {"model": UnauthorizedResponse},
      403: {"model": ForbiddenResponse},
      404: {"model": NotFoundResponse},
      409: {"model": ConflictResponse},
      422: {"model": UnprocessableContentResponse}
  })


  @router.get("/", response_model=BulkResponse[User])
  async def root():
      ls = [
          User(id=1, name="John Doe"),
          User(id=2, name="Jane Boe")
      ]
      return await BulkResponse(data=ls).as_json_response()

  app.include_router(router)
  if __name__=="__main__":
      uvicorn.run(app, host="localhost", port=8000)
  ```

  This project was inspired by the work of [Mr.MohammadAli Soltanipoor](https://github.com/soltanipoor) on OpenAPI.


pkgId: ba83bffecef0b0efe341844d796245b1f35559a0114b00b68b557f01fec5c673
name: python-bascirpg-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for bascirpg
url: https://github.com/Unlisted27/basicrpg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bascirpg-0.0.1-1.src.rpm
location_href: Packages/python-bascirpg-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  "Uuuugggg" -The sound I make when I need to format a new README.md file


  Author: Unlisted_dev

  Welcome to BasicRPG!
  This is a python module for making RPG games, clean and easy.




  My intent for this project was to make it as begginer friendly as possible. While there are some fairly advanced things in here, I try to explain it as much as I can. I encourage you to experiment with the small number of premade assets included in the starter_pack, and then go make your own! Every folder in this project has a README.md that will contain some useful pieces of information. If anything is intimidating to you right now, go through the project and read the READMEs.


  Im not gonna tell you what they do though, figure that out
  race
  profession
  character
  food
  weapon


  Wanna hear a backstory? Sure you do.
  I started learning to code in grade 1 or 2 with scratch. I loved making games and learning new things. Every game I made, I added a new mechanic that used concepts I didnt know of before, and this was how I learnt. Honestly, it was the best way to learn in my opinion (take some notes [INSERT NAME OF EDUCATIONAL INSTITUTION]). In grade 5, I wanted something new, scratch was making me feel like a boring programmer, so I found python. I took some online class in python, codeAcademy I think, which was great for learning the basics, but soon it felt overcomplicated, too much boring math that I didn't understand. YouTube was my saviour, I learned how to take a user input and that was all I needed. For the next few years I made choose your own adventure games, but my programming skills improved barely at all. I created little projects from time to time, but often got confused or lost. After a break from coding, almost too long, something rekindled my interest, and I set out to make a new choose your own adventure game that would be organised this time. I didn't want what happened to me the last million times to happen again, and it didn't. I succesfully created my first COMPLETE choose your own adventure game in python, and it only took 3 years... What really started my leap in programming skill was when I discoverd linux developer mode on my school laptop, and downloaded my favourite code editor: VScode. Every chance I got, whenever I was bored in class, I stopped playing brain rotting games and started coding. What else is school for? Ever since then, I have learned more and more. I consumed nerd knowledge like a sponge, put live operating systems on old USB drives, repaired thrown away computers with salvaged parts, programmed everything I was interested in in that moment from neural networks to fibinachi sequence generators, created a GitHub account to share my creations with the world. Some of you may say "Wow so incredible", other may say "Yeah, we've all been there, done that", either way, I don't care what you think. So then why did I publish my villian arc? Because maybe you, yes you, are starting your programming journey, and I want you to know how much there is to learn, and how much is out there. The world of technology has so much to offer, and it's not only for losers who do nothing but pre-cal homework and try-harding the shit out of school, it can be for you to, just like it was for me. In this project, I have included tones of comments in an attempt to explain as much as I can. I hope you will learn something.


  After writing all that, I forgot what a README is suposed to have, so i'll put what's on my mind here
  -I really need some neat ascii art in some part of this project, like that would be absolutly sick
  -Better do real README stuff, tommorow tho, it's too late.
  -Oh ya, find bugs, DM me
  -also like and subscribe, or whatever GitHub has


  Literaly anything, don't be weird. DMs always open: Unlisted_dev (discord)


  Ps: You don't have to be a gay furry either, although they do have a plus 15 on all programming related rolls


pkgId: 7838df9c62901ca9086300b1d48b53c83265a74c0638598c0d8c1f0071c724a1
name: python-base-saiCxDataFrameloader-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for base-saiCxDataFrameloader
url: https://github.com/amitgupta7/base-saiCxDataFrameloader
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-base-saiCxDataFrameloader-0.1.0-1.src.rpm
location_href: Packages/python-base-saiCxDataFrameloader-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A package for loading data frames for cx data files.



  You can install the package using pip:

  ```bash
  pip install base-saiCxDataFrameloader
  ```



  ```
  import base_saiCxDataFrameloader


  ```


  Contributions are welcome! Please open an issue or submit a pull request.


pkgId: cc8d8fb17538bbe2b38263c4ae8dd7b27de9d7803e8cc0bf4384ccf1b63be0e3
name: python-base62-py-help
arch: noarch
version: 1.3.13
epoch: 0
release: 1
summary: Development documents and examples for base62-py
url: https://github.com/cyrildever/base62
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-base62-py-1.3.13-1.src.rpm
location_href: Packages/python-base62-py-help-1.3.13-1.noarch.rpm
checksum_type: sha256
description:
  _Custom Base-62 Encoder_

  ![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/base62)
  ![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/base62)
  ![GitHub issues](https://img.shields.io/github/issues/cyrildever/base62)
  ![npm](https://img.shields.io/npm/dw/base62-ts)
  ![NPM](https://img.shields.io/npm/l/base62-ts)

  This repository contains the version of my encoder/decoder for Base-62 in three languages:
  * [Golang](https://github.com/cyrildever/base62);
  * Python;
  * [TypeScript](https://github.com/cyrildever/base62/ts).




  I needed an efficient way to apply a Base-62 encoding/decoding algorithm working the same way in TypeScript/Javascript, Golang and Python environments.




  Both versions use the same following dictionary:

  | Value | Character | Value | Character | Value | Character | Value | Character | Value | Character |
  |:-----:|:---------:|:-----:|:---------:|:-----:|:---------:|:-----:|:---------:|:-----:|:---------:|
  |   0   |    `0`    |   13  |    `d`    |   26  |    `q`    |   39  |    `D`    |   52  |    `Q`    |
  |   1   |    `1`    |   14  |    `e`    |   27  |    `r`    |   40  |    `E`    |   53  |    `R`    |
  |   2   |    `2`    |   15  |    `f`    |   28  |    `s`    |   41  |    `F`    |   54  |    `S`    |
  |   3   |    `3`    |   16  |    `g`    |   29  |    `t`    |   42  |    `G`    |   55  |    `T`    |
  |   4   |    `4`    |   17  |    `h`    |   30  |    `u`    |   43  |    `H`    |   56  |    `U`    |
  |   5   |    `5`    |   18  |    `i`    |   31  |    `v`    |   44  |    `I`    |   57  |    `V`    |
  |   6   |    `6`    |   19  |    `j`    |   32  |    `w`    |   45  |    `J`    |   58  |    `W`    |
  |   7   |    `7`    |   20  |    `k`    |   33  |    `x`    |   46  |    `K`    |   59  |    `X`    |
  |   8   |    `8`    |   21  |    `l`    |   34  |    `y`    |   47  |    `L`    |   60  |    `Y`    |
  |   9   |    `9`    |   22  |    `m`    |   35  |    `z`    |   48  |    `M`    |   61  |    `Z`    |
  |   10  |    `a`    |   23  |    `n`    |   36  |    `A`    |   49  |    `N`    |       |           |
  |   11  |    `b`    |   24  |    `o`    |   37  |    `B`    |   50  |    `O`    |       |           |
  |   12  |    `c`    |   25  |    `p`    |   38  |    `C`    |   51  |    `P`    |       |           |

  In other words, they use the following base: `0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`.

  ```console
  pip install base62-py
  ```

  ```python
  from base62 import decode, encode

  value = 18969

  encoded = encode(value)


  print(encoded)

  decoded = decode(encoded)

  assert value == decoded
  ```




  ```console
  $ pip install -e . && python3 -m unittest discover
  ```




  Both versions are available under a MIT license (see [LICENSE](LICENSE)).


  <hr />
  &copy; 2021-2024 Cyril Dever. All rights reserved.

rpm_license:
  MIT License  Copyright (c) 2024 Cyril Dever  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: bc3acbec67c51c9cfcb059f349f1a2b1ad43d1b8463c904b5786c8abc403bf48
name: python-baseapp-chats-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for baseapp-chats
url: https://github.com/silverlogic/baseapp-backend
rpm_license: BSD-3-Clause # Example license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-baseapp-chats-0.0.5-1.src.rpm
location_href: Packages/python-baseapp-chats-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  This package provides a simple chat system for your project, where multiple profiles can chat with each other.



  ```
  - **baseapp-core** >= 0.3.7
  - **baseapp-profile** >= 0.2.4
  ```

  Run `pip install baseapp-chats`
  And make sure to add the frozen version to your `requirements/base.txt` file

  If you want to develop, [install using this other guide](#how-to-develop).



  Add `baseapp_chats` to your project's `INSTALLED_APPS`

  Make sure your Profile's GraphQL Object Types extends `ChatRoomsInterface` interface:

  ```python
  from baseapp_chats.graphql.interfaces import ChatRoomsInterface

  class ProfileObjectType(DjangoObjectType):
      class Meta:
          interfaces = (relay.Node, ChatRoomsInterface)
  ```

  This is not necessary if you are using the `baseapp-profile` as it is without a custom ProfileObjectType implementation.

  Expose `ChatsMutations`, `ChatsQueries` and `ChatsSubscriptions` in your GraphQL/graphene endpoint, like:

  ```python
  from baseapp_chats.graphql.mutations import ChatsMutations
  from baseapp_chats.graphql.queries import ChatsQueries
  from baseapp_chats.graphql.subscriptions import ChatsSubscriptions


  class Query(graphene.ObjectType, ChatsQueries):
      pass


  class Mutation(graphene.ObjectType, ChatsMutations):
      pass


  class Subscription(graphene.ObjectType, ChatsSubscriptions):
      pass


  schema = graphene.Schema(query=Query, mutation=Mutation, subscription=Subscription)
  ```

  Those will expose the following queries, mutations and subscriptions:



  - `chatRoom(id: ID!)`: Return a specific chatRoom



  - `chatRoomCreate(profileId: ID!, participants: [ID!]!)`: Create a chatRoom with your profile and multiple participants
  - `chatRoomSendMessage(roomId: ID!, profileId: ID!, content: String!, inReplyToId: ID)`: Send a message in a room, using a specific profile. Optionally, you can reply to a message by passing the `inReplyToId` argument.
  - `chatRoomReadMessages(roomId: ID!, profileId: ID!, messageIds: [ID])`: Mark messages in a room as read by a specific profile, if `messageIds` is not passed, all messages will be marked as read.



  - `chatRoomOnRoomUpdate(profileId: ID!)`: Subscribe to chat rooms updates under your current profile
  - `chatRoomOnMessagesCountUpdate(profileId: ID!)`: Subscribe to unread/read messages count updates under your current profile
  - `chatRoomOnNewMessage(roomId: ID!)`: Subscribe to new messages in a specific room



  Clone the project inside your project's backend dir:

  ```
  git clone git@github.com:silverlogic/baseapp-backend.git
  ```

  And manually install the package:

  ```
  pip install -e baseapp-backend/baseapp-chats
  ```

  The `-e` flag will make it like any change you make in the cloned repo files will effect into the project.


pkgId: bb6f310704878647fedbff32e3dc8bf12dc2826bd37182904216c01be0c085e7
name: python-baseapp-profiles-help
arch: noarch
version: 0.3.6
epoch: 0
release: 1
summary: Development documents and examples for baseapp-profiles
url: https://github.com/silverlogic/baseapp-backend
rpm_license: BSD-3-Clause # Example license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-baseapp-profiles-0.3.6-1.src.rpm
location_href: Packages/python-baseapp-profiles-help-0.3.6-1.noarch.rpm
checksum_type: sha256
description:
  Reusable app to handle profiles, URL's paths and metadata. It provides useful models and GraphQL Interfaces.



  And install the package with `pip install baseapp-profiles`.

  If you want to develop, [install using this other guide](#how-to-develop).



  Add `baseapp_profiles` to your project's `INSTALLED_APPS` and run `./manage.py migrate` as any other django model:

  ```python
  INSTALLED_APPS = [
      'baseapp_profiles',
  ]
  ```

  Add `baseapp_profiles.middleware.CurrentProfileMiddleware` to the `MIDDLEWARE` list in your django settings file, make sure it is **after** `django.contrib.auth.middleware.AuthenticationMiddleware`.

  Add `baseapp_profiles.permissions.ProfilesPermissionsBackend` to the `AUTHENTICATION_BACKENDS` list in your django settings file.

  Expose `ProfilesMutations` and `ProfilesQuery` in your GraphQL/graphene endpoint, like:

  ```python
  from baseapp_profiles.graphql.mutations import ProfilesMutations
  from baseapp_profiles.graphql.queries import ProfilesQuery

  class Query(graphene.ObjectType, ProfilesQuery):
      pass

  class Mutation(graphene.ObjectType, ProfilesMutations):
      pass

  schema = graphene.Schema(query=Query, mutation=Mutation)
  ```



  `ProfileInterface` is a GraphQL interface that can be used to query for profiles. It has the following fields:

  - `profile` return the `Profile` for the object



  General development instructions can be found in [main README](..#how-to-develop).


pkgId: ebae7b0add48b46c284c0df41c6386f4922b9ecd17e0e5631e249436bebfb8bc
name: python-basecase-help
arch: noarch
version: 4.33.10
epoch: 0
release: 1
summary: Development documents and examples for basecase
url: https://github.com/seleniumbase/SeleniumBase
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-basecase-4.33.10-1.src.rpm
location_href: Packages/python-basecase-help-4.33.10-1.noarch.rpm
checksum_type: sha256
description:
  📚 Learn from [**over 200 examples** in the **SeleniumBase/examples/** folder](https://github.com/seleniumbase/SeleniumBase/tree/master/examples).
  👤 Note that <span translate="no">SeleniumBase</span> <a translate="no" href="https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/uc_mode.md"><b>UC Mode</b> (Stealth Mode) has its own ReadMe</a>.
  🐙 Also note that Seleniumbase <a href="https://github.com/seleniumbase/SeleniumBase/blob/master/examples/cdp_mode/ReadMe.md"><b>CDP Mode</b> has its own separate ReadMe</a>.
  ℹ️ Scripts can be called via <code translate="no"><b>python</b></code>, although some <a href="https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/syntax_formats.md">Syntax Formats</a> expect <a href="https://docs.pytest.org/en/latest/how-to/usage.html" translate="no"><b>pytest</b></a> (a Python unit-testing framework included with SeleniumBase that can discover, collect, and run tests automatically).
  <p align="left">📗 Here's <a href="https://github.com/seleniumbase/SeleniumBase/blob/master/examples/my_first_test.py">my_first_test.py</a>, which tests login, shopping, and checkout:</p>
  ```bash
  pytest my_first_test.py
  ```
  <a href="https://github.com/seleniumbase/SeleniumBase/blob/master/examples/my_first_test.py"><img src="https://seleniumbase.github.io/cdn/gif/fast_swag_2.gif" alt="SeleniumBase Test" title="SeleniumBase Test" width="520" /></a>


pkgId: 3ff6ad03fd17802ff5cc0d6ec4215f1ff1e03b0d5993648f31d34743bd32da36
name: python-basilisp-help
arch: noarch
version: 0.3.5
epoch: 0
release: 1
summary: Development documents and examples for basilisp
url: https://github.com/basilisp-lang/basilisp
rpm_license: Eclipse Public License 1.0 (EPL-1.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-basilisp-0.3.5-1.src.rpm
location_href: Packages/python-basilisp-help-0.3.5-1.noarch.rpm
checksum_type: sha256
description:
  A Clojure-compatible(-ish) Lisp dialect targeting Python 3.9+.

  [![PyPI](https://img.shields.io/pypi/v/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![python](https://img.shields.io/pypi/pyversions/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![pyimpl](https://img.shields.io/pypi/implementation/basilisp.svg?style=flat-square)](https://pypi.org/project/basilisp/) [![readthedocs](https://img.shields.io/readthedocs/basilisp.svg?style=flat-square)](https://basilisp.readthedocs.io/) [![Run tests](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/basilisp-lang/basilisp/actions/workflows/run-tests.yml) [![Coveralls github](https://img.shields.io/coveralls/github/basilisp-lang/basilisp.svg?style=flat-square)](https://coveralls.io/github/basilisp-lang/basilisp) [![license](https://img.shields.io/github/license/basilisp-lang/basilisp.svg?style=flat-square)](https://github.com/basilisp-lang/basilisp/blob/master/LICENSE)



  Basilisp is developed on [GitHub](https://github.com/basilisp-lang/basilisp) and
  hosted on [PyPI](https://pypi.python.org/pypi/basilisp). You can fetch Basilisp
  using `pip`:

  ```bash
  pip install basilisp
  ```

  Once Basilisp is installed, you can enter into the REPL using:

  ```bash
  basilisp repl
  ```

  Basilisp [documentation](https://basilisp.readthedocs.io) can help guide your
  exploration at the REPL. Additionally, Basilisp features many of the same functions
  and idioms as [Clojure](https://clojure.org/), so you may find guides and
  documentation there helpful for getting started.

  For those who prefer a video introduction, feel free to check out this
  [talk](https://youtu.be/ruGRHYpq448?si=0jr2a6uWlq6Vi2_k) hosted by the
  [London Clojurians](https://www.meetup.com/london-clojurians/) group about Basilisp.



  Basilisp is a project I (@chrisrink10) created to learn about Python, Clojure,
  hosted  languages, and compilers.

  That said, it is generally stable at this point with reasonably high test
  coverage, linting, and type checking. Work is ongoing to complete the rest of the
  standard the library implementations. I suspect it could be used to build small
  applications and tools at this point, though I would not recommend it unless you
  like being an early adopter.

  _Use in a production setting at your own risk._



  Eclipse Public License 1.0


pkgId: 938533c3cc619f8bc1ec270a454e40654e712b8061bfdb48731230fe1185698a
name: python-batchalign-help
arch: noarch
version: 0.7.4
epoch: 0
release: 1
summary: Development documents and examples for batchalign
url: https://pypi.org/project/batchalign/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-batchalign-0.7.4-1.src.rpm
location_href: Packages/python-batchalign-help-0.7.4-1.noarch.rpm
checksum_type: sha256
description:
  The following instructions provide a quick start to installing Batchalign. For most users aiming to process CHAT and audio with Batchalign, we recommend more detailed usage instructions: for [usage](https://talkbank.org/info/BA2-usage.pdf) and [human transcript cleanup](https://talkbank.org/info/BA2-cleanup.pdf). The following provides a quick start guide for the program.

  - We support Python versions 3.9, 3.10, and 3.11.
  - **We do not support Python 3.12** (no PyTorch support)
  - To install Python, follow the instructions...
      -  for macOS
          1. Install Brew: [visit this link](https://brew.sh/)
          2. Install Python: execute `brew install python@3.11`
      -  for Windows
          1.  Install Python 3.11: [via this link](https://www.python.org/ftp/python/3.11.7/python-3.11.7-amd64.exe)
          2.  If later commands report `pip module not found`, [this page may help](https://stackoverflow.com/a/15626784)
      -  your distribution's instructions for Linux

  You can get Batchalign from PyPi, and you can update the package in the same way:
  macOS/Linux:
  ```
  pip install -U batchalign
  ```
  Windows:
  ```
  py -m pip install -U batchalign
  ```

  There are two main ways of interacting with Batchalign. Batchalign can be used as a program to batch-process CHAT (hence the name), or as a Python LSA library.
  - to get started with the Batchalign program, [tap here](#quick-start-command-line)
  - to get started on the Batchalign Library (assumes familiarity with Python), [tap here](#quick-start-python)


  Once installed, you can invoke the Batchalign program by typing `batchalign` into the Terminal (MacOS) or Command Prompt (Windows).
  It is used in the following basic way:
  ```
  batchalign [verb] [input_dir] [output_dir]
  ```
  Where `verb` includes:
  1. `transcribe` - by placing only an audio of video file (`.mp3/.mp4/.wav`) in the input directory, this function performs ASR on the audio, diarizes utterances, identifies some basic conversational features like retracing and filled pauses, and generates word-level alignments. You must supply a language code flag: `--lang=[three letter ISO language code]` for the ASR system to know what language the transcript is in. You can choose the flags `--rev` to use Rev.AI, a commercial ASR service, or `--whisper`, to use a local copy of OpenAI Whisper.
  2. `align` - by placing both an audio of video file (`.mp3/.mp4/.wav`) and an *utterance-aligned* CHAT file in the input directory, this function recovers utterance-level time alignments (if they are not already annotated) and generates word-level alignments. The @Languages header in the CHAT file tells the program which language is in the transcript.
  3. `morphotag` - by placing a CHAT file in the input directory, this function uses Stanford NLP Stanza to generate morphological and dependency analyses. The @Languages header in the CHAT file tells the program which language is in the transcript. You must supply a language code flag: `--lang=[three letter ISO language code]` for the alignment system to know what language the transcript is in.
  <!-- 4. `bulletize` - placing both an audio of video file (`.mp3/.mp4/.wav`) and an *unlinked* CHAT file in the input directory, generate utterance-level alignments through ASR -->
  You can get a CHAT transcript to experiment with [at the TalkBank website](https://talkbank.org/), under any of the "Banks" that are available. You can also generate and parse a CHAT transcript via [the Python program](https://github.com/TalkBank/batchalign2?tab=readme-ov-file#chat).

  For input files (CHAT and audio for `align`, CHAT only for `morphotag`, and audio only for `transcribe`), located in `~/ba_input` dumping the output to `~/ba_output`, one could write:

  ```
  batchalign transcribe --lang=eng ~/ba_input ~/ba_output
  ```

  ```
  batchalign morphotag ~/ba_input ~/ba_output
  ```

  ```
  batchalign align --lang=eng ~/ba_input ~/ba_output


pkgId: 4f3fc0daabb0773adcd67c35ee6245dd17a17b3f1d37894883c6a452cb7a689b
name: python-batched-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for batched
url: https://pypi.org/project/batched/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-batched-0.1.3-1.src.rpm
location_href: Packages/python-batched-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  The Batched API provides a flexible and efficient way to process multiple requests in a batch, with a primary focus on dynamic batching of inference workloads. It is designed to optimize throughput while maintaining a low-latency experience, especially useful in scenarios where you need to handle a high volume of requests simultaneously. It is designed for both async and sync execution.

  ![Batch Performance](/examples/inference_speed.png)



  - [Installation](#installation)
  - [Usage](#usage)
    - [Basic Example](#basic-example)
    - [Advanced Usage](#advanced-usage)
  - [API Reference](#api-reference)
  - [Contributing](#contributing)
  - [License](#license)



  Dynamic batching is a technique that automatically groups multiple incoming inference requests into a single batch for processing. This is particularly beneficial for inference workloads, where processing multiple inputs together can significantly improve throughput and efficiency.

  In machine learning models, dynamic batching matters because it optimizes hardware utilization, especially for GPUs and specialized AI hardware designed for parallel processing. By batching requests, we can fully leverage this parallel processing, leading to higher throughput. It also reduces overhead by amortizing fixed costs (such as data transfer and model initialization) across multiple requests, improving overall efficiency. Furthermore, dynamic batching enhances real-time performance by adapting to varying request rates, maintaining low latency during quiet periods while maximizing throughput during busy times.

  This makes dynamic batching a crucial technique for deploying ML models in production environments where request patterns can be unpredictable and resource optimization is key.



  To install the Batched, you can use pip:

  ```bash
  pip install batched
  ```





  Below is a basic example of how to use the Batched API to process text data in batches.

  ```diff
     from sentence_transformers import SentenceTransformer
     import numpy as np
  +  import batched

     class SentenceEmbedder:
        def __init__(self, model_name='mixedbread-ai/mxbai-embed-large-v1'):
           self.model = SentenceTransformer(model_name)

  +     @batched.dynamically
        def embed_sentences(self, sentences: list[str]) -> list[np.ndarray]:
           
           return self.model.encode(sentences)

     
     embedder = SentenceEmbedder()

     
     single_sent = "This is a test sentence."
     embedding = embedder.embed_sentences(single_sent)
  +  awaited_embedding = await embedder.embed_sentences.acall(single_sent)

     
     batch_sentences = [f"This is test sentence number {i}." for i in range(1000)]
     batch_embeddings = embedder.embed_sentences(batch_sentences)
  +  awaited_batch_embeddings = await embedder.embed_sentences.acall(batch_sentences)

     
  +  stats = embedder.embed_sentences.stats
  ```



  For more advanced usage, such as customizing batch size and timeout dynamically, the Batched API provides decorators that allow fine-grained control over the batching process.

  - **Batch Size**: You can specify the max. number of requests to group together in a single batch.
  - **Timeout**: The maximum time to wait for more requests before processing the batch.
  - **Small Batch Threshold**: The threshold to give more priority to smaller batches.
  - **Pad Token**: The token to use for padding when batching tensors, only for `@inference.dynamically` and `@aio.inference.dynamically`.

  For example:

  ```python
  @batched.dynamically(batch_size=64, timeout_ms=5.0, small_batch_threshold=2)
  def custom_batch_function(data):
      
      pass
  ```



  The API offers both thread and asyncio implementations for batching general tasks and inference tasks:



  - `@batched.dynamically`: Allows dynamic batching for general tasks (Both sync and async supported).
  - The decorated method should:
    - Take in a list of items (`list[T]`)
    - Return a list of results (`list[U]`) of the same length.

  ```python
  import batched


  @batched.dynamically(batch_size=64)
  def my_function(items: list[int]) -> list[str]:
    
    return [f"{item * 2}" for item in items]


  my_function(2)


  my_function([2, 3, 4])


  await my_function.acall(2)
  await my_function.acall([2, 3, 4])


  print(my_function.stats)
  ```

  - `@batched.inference.dynamically`: Allows dynamic batching for inference tasks, handling numpy arrays and tensors with padding.
  - The decorated method should:
    - Take in a dictionary of tensors or numpy arrays (`dict[str, Feature]`). `Feature` is a batch of item values for a single feature, and the keys are the feature names.
    - Return a tensor or numpy array (`Feature`). Each row is a single inference result.
    - `Feature` can be any of the following types: `np.ndarray`, `torch.Tensor`, `list[np.ndarray]` and `list[torch.Tensor]`.
    - `features[feature_name].shape[0] == outputs.shape[0]`

  ```python
  from batched import inference
  import torch

  @inference.dynamically(pad_token={"input_ids": 0})
  def my_inference_function(features: dict[str, torch.Tensor]) -> torch.Tensor:
    
    
    

    logits = model(**features)
    return logits


  my_inference_function(data)


  await my_inference_function.acall(data)

  print(my_inference_function.stats)
  ```



  - `@batched.aio.dynamically`: Allows dynamic batching for general tasks using `asyncio`.
  - The decorated method should:
    - Take in a list of items (`list[T]`)
    - Return a list of results (`list[U]`) of the same length.

  ```python
  from batched import aio

  @aio.dynamically(batch_size=64, timeout_ms=20.0, small_batch_threshold=10)
  def my_function(items: list[int]) -> list[int]:  # can also be an async function: async def ...
    
    return [item * 2 for item in items]



  await my_function(2)


  await my_function([2, 3, 4])


  print(my_function.stats)
  ```

  - `@batched.aio.inference.dynamically`: Allows dynamic batching for inference tasks, handling numpy arrays and tensors with padding, using `asyncio`.
  - The decorated method should:
    - Take in a dictionary of tensors or numpy arrays (`dict[str, Feature]`). `Feature` is a batch of item values for a single feature, and the keys are the feature names.
    - Return a tensor or numpy array (`Feature`). Each row is a single inference result.
    - `Feature` can be any of the following types: `np.ndarray`, `torch.Tensor`, `list[np.ndarray]` and `list[torch.Tensor]`.
    - `features[feature_name].shape[0] == outputs.shape[0]`

  ```python
  from batched import aio
  import torch

  @aio.inference.dynamically(pad_token={"input_ids": 0})
  async def my_inference_function(features: dict[str, torch.Tensor]) -> list[torch.Tensor]:
    
    
    

    logits1 = await model1(**features)
    logits2 = await model2(**features)
    return [logits1, logits2]


  await my_inference_function(data)

  print(my_inference_function.stats)
  ```



  Contributions are welcome! Please feel free to submit a pull request or report an issue on GitHub.



  This project was inspired by the following projects:

  - [Infinity](https://github.com/michaelfeil/infinity) by Michael Feil



  This project is licensed under the Apache License, Version 2.0.


pkgId: c70fec2658b929c08bb2cb73cb05b27f4fe84e1c919ffbd5ab08a24cc10e1898
name: python-batchfetch-help
arch: noarch
version: 1.2.6
epoch: 0
release: 1
summary: Development documents and examples for batchfetch
url: https://github.com/jamescherti/batchfetch
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-batchfetch-1.2.6-1.src.rpm
location_href: Packages/python-batchfetch-help-1.2.6-1.noarch.rpm
checksum_type: sha256
description:
  tasks:
    
    
    - git: https://github.com/noctuid/general.el
    
    
    - git: https://github.com/minad/consult
      revision: "1.5"
    
    - git: https://github.com/magnars/s.el
      path: another-name.el
      revision: dda84d38fffdaf0c9b12837b504b402af910d01d
    
    - git: https://github.com/skeeto/impatient-mode
      delete: true
  ```
  Execute the `batchfetch` command from the same directory as `batchfetch.yml` to make it clone or update the local copies of the repositories above.

  Here are the various options that `batchfetch` provides, along with descriptions of their usage:
  ```
  usage: batchfetch [--option] [args]
  Command line interface.
  positional arguments:
    N                     Specify the batchfetch YAML file(s) (default: './batchfetch.yaml').
  options:
    -h, --help            show this help message and exit
    -j JOBS, --jobs JOBS  Run up to N Number of parallel processes (Default: 5).
    -v, --verbose         Enable verbose mode.
  ```


  The parent directory of the "path:" value defines the managed directory, where the directory of each path is considered as the managed directory.
  For example, if the "path:" value is `file/my-project`, the managed directory will be `file/`. Any file within `file/` that is not managed by batchfetch will be considered an untracked file.
  When *batchfetch* encounters an untracked file, it displays an error message to inform users about paths that are not managed by the system. The message provides clear instructions on how to handle these paths by adding them to the `options.ignore_untracked_paths` list, enabling users to manage untracked files effectively.
  Here is an example of a *batchfetch.yaml* file that enables *batchfetch* to accept a list of untracked files:
  ``` yaml
  options:
    ignore_untracked_paths:
      - ./test
      - /absolute/path
      - ../relative/path
  tasks:
    - git: https://github.com/user/project
  ```
  By default, *batchfetch.yaml* is the only untracked file that is ignored. The user does not need to add it to the *ignore_untracked_paths* option.

  Copyright (C) 2024 [James Cherti](https://www.jamescherti.com)
  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program.

  - [batchfetch @GitHub](https://github.com/jamescherti/batchfetch)
  - [batchfetch @Pypi](https://pypi.org/project/batchfetch/)


pkgId: b33d1a267294715f289b8e7875f95ab4198dc1ce00d37b5deae65a02faf2954f
name: python-batogram-help
arch: noarch
version: 1.5.0
epoch: 0
release: 1
summary: Development documents and examples for batogram
url: https://github.com/jmears63/batogram
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-batogram-1.5.0-1.src.rpm
location_href: Packages/python-batogram-help-1.5.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Screen Shot](docs/screenshot.png "Screen Shot")
  Batogram is an open source application for viewing bat call spectrograms.
  Some capabilities and features:
  * Rendering of spectrograms from .wav files.
  * Audio playback: direct, heterodyne and time division, write to .wav file.
  * Auto selection of many parameters for simple operation.
  * Efficient rendering with graceful handling of larger data files.
  * Pan and scale using the mouse, keys or by manual selection.
  * Graphical markers allow time and frequency ranges to be conveniently read.
  * Handling of multichannel data files, including stereo.
  * Ability to correct for microphone frequency response.
  * Basic side by side comparison of two spectrograms.
  * Folder view to conveniently review, flag and perform actions on items (move, copy, prefix, delete, etc).
  * Display of GUANO metadata, including the ability to click to open the location in Google Maps.
  * Runs on Windows, Linux operating systems, macOS (experimental).

rpm_license:
  Copyright (c) 2023 John Mears  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: 22d4cfe84e4ea5b1d26a58c4518c6ec6d1e8880d744a9dba4b27ea001c488c62
name: python-bayesian-network-generator-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for bayesian-network-generator
url: https://github.com/rudzanimulaudzi/bayesian_network_generator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bayesian-network-generator-0.0.7-1.src.rpm
location_href: Packages/python-bayesian-network-generator-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  **Bayesian Network Generator Package** is a Python library for building, analyzing, and visualizing Bayesian Networks. It leverages libraries like `pgmpy`, `numpy`, and `matplotlib` to help create estimate Bayesian network structures, parameters, construct Conditional Probability Tables (CPTs), and create visualizations for your Bayesian Network models.

  The library is currently focused on generating discrete values and the states are informed by the `cardinarlity` variable, this cardinarlity is the number of states a variable can have.




  Bayesian network creation tool. Use to generate Bayesian Networks at scale.

  - **Create Bayesian Network**: Learn optimal Conditional Probability Distributions (CPDs) using neural networks.
  - **Generate Samples**: Build Conditional Probability Tables using model weights.
  - **Visualise Bayesian Networks**: Generate network graphs and visualizations of CPDs.
  - **Utilities**: Includes helper functions to streamline Bayesian Network workflows.





  To install this modul run

  ```bash
    pip install bayesian_network_generator
  ```




  bng has the following non-optional dependencies:

  - numpy
  - pandas
  - networkx
  - pgmpy
  - matplotlib
  - sklearn
  - seaborn
  - pickle
  - os
  - pathlib
  - datetime
  - json



  The main function is **create_pgm**

  Then function is used to create a probabilistic graphical model (PGM) and accompanying sample data.

  **Parameters**:
  ```python
  num_nodes ( int): Number of nodes in the PGM.

  node_cardinality (int or dict): Cardinality of nodes.

  max_indegree (int): Maximum in-degree for any node.

  density (str): Network density - 'normal', 'sparse', or 'dense'.

  skew (float, int, dict): Skew to be applied.

  noise (float): Noise level to be added to the data.

  missing_data_percentage (float): Percentage of missing data.

  sample_size (int): Number of samples to be generated.

  visualize (bool): Whether to visualize the network and CPDs.

  artifacts_output_dir (str): directory to store created artifacts like the pickle model and sample data
  ```

  **Returns**:
  ```
  dict: Dictionary containing the model, samples, and runtime.
  ```

  ```python
  import bayesian_network_generator as bng

  result = bng.create_pgm()

  ```

  Output
  2024-12-16 13:12:55,950 - create_cpds - INFO - Starting PGM creation

  INFO:create_cpds:Starting PGM creation

  2024-12-16 13:12:55,953 - create_cpds - INFO - Prepared, name_of_nodes, edges, model, node_cardinality_dict = ['N0', 'N1', 'N2'], [('N0', 'N1')], BayesianNetwork with 2 nodes and 1 edges, {'N0': 2, 'N1': 2, 'N2': 2}

  INFO:create_cpds:Prepared, name_of_nodes, edges, model, node_cardinality_dict = ['N0', 'N1', 'N2'], [('N0', 'N1')], BayesianNetwork with 2 nodes and 1 edges, {'N0': 2, 'N1': 2, 'N2': 2}

  2024-12-16 13:12:55,955 - create_cpds - INFO - Generated {1} edges for the Bayesian Network

  INFO:create_cpds:Generated {1} edges for the Bayesian Network
  Generating for node: N1: 100%|██████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 366.76it/s]
  /opt/anaconda3/envs/deep_cpds/lib/python3.11/site-packages/pgmpy/sampling/base.py:598: FutureWarning: Passing a DataFrame to DataFrame.from_records is deprecated. Use set_index and/or drop to modify the DataFrame instead.
    df = pd.DataFrame.from_records(samples)
  2024-12-16 13:12:55,997 - create_cpds - INFO - PGM creation completed in 0.04613900184631348 seconds

  INFO:create_cpds:PGM creation completed in 0.04613900184631348 seconds

  ```python
  In [3]: result
  Out[3]:
  {'model': <pgmpy.models.BayesianNetwork.BayesianNetwork at 0x178a0c490>,
   'samples':      N0  N1
   0     0   0
   1     0   1
   2     0   0
   3     0   1
   4     0   1
   ..   ..  ..
   995   0   1
   996   0   1
   997   0   0
   998   0   0
   999   0   0

   [1000 rows x 2 columns],
   'runtime': 0.04613900184631348}
  ```

  ```python
  In [4]: result['model']
  Out[4]: <pgmpy.models.BayesianNetwork.BayesianNetwork at 0x178a0c490>

  In [5]: result['model'].edges
  Out[5]: OutEdgeView([('N0', 'N1')])

  In [6]: result['model'].nodes
  Out[6]: NodeView(('N0', 'N1'))

  In [8]: result['samples']
  Out[8]:
       N0  N1
  0     0   0
  1     0   1
  2     0   0
  3     0   1
  4     0   1
  ..   ..  ..
  995   0   1
  996   0   1
  997   0   0
  998   0   0
  999   0   0

  [1000 rows x 2 columns]

  ```

  ```python
  In [12]: bng.create_pgm(num_nodes=7, node_cardinality=5, max_indegree=4, density="normal", skew=0.75, noise=0.1, missing_data_percentag
      ...: e=0, sample_size=1000, visualize=True)

  ```

  2024-12-16 13:18:38,489 - create_cpds - INFO - Starting PGM creation

  INFO:create_cpds:Starting PGM creation

  2024-12-16 13:18:38,491 - create_cpds - INFO - Prepared, name_of_nodes, edges, model, node_cardinality_dict = ['N0', 'N1', 'N2', 'N3', 'N4', 'N5', 'N6'], [('N2', 'N5'), ('N0', 'N3'), ('N2', 'N3'), ('N0', 'N1'), ('N2', 'N0'), ('N1', 'N4'), ('N5', 'N4'), ('N3', 'N1'), ('N6', 'N5')], BayesianNetwork with 7 nodes and 9 edges, {'N0': 5, 'N1': 5, 'N2': 5, 'N3': 5, 'N4': 5, 'N5': 5, 'N6': 5}

  INFO:create_cpds:Prepared, name_of_nodes, edges, model, node_cardinality_dict = ['N0', 'N1', 'N2', 'N3', 'N4', 'N5', 'N6'], [('N2', 'N5'), ('N0', 'N3'), ('N2', 'N3'), ('N0', 'N1'), ('N2', 'N0'), ('N1', 'N4'), ('N5', 'N4'), ('N3', 'N1'), ('N6', 'N5')],

  BayesianNetwork with 7 nodes and 9 edges, {'N0': 5, 'N1': 5, 'N2': 5, 'N3': 5, 'N4': 5, 'N5': 5, 'N6': 5}

  2024-12-16 13:18:38,496 - create_cpds - INFO - Generated {9} edges for the Bayesian Network

  INFO:create_cpds:Generated {9} edges for the Bayesian Network
  Generating for node: N4: 100%|█████████████████████████████████████████████████████████████████████████| 7/7 [00:00<00:00, 2363.18it/s]
  /opt/anaconda3/envs/deep_cpds/lib/python3.11/site-packages/pgmpy/sampling/base.py:598: FutureWarning: Passing a DataFrame to DataFrame.from_records is deprecated. Use set_index and/or drop to modify the DataFrame instead.
    df = pd.DataFrame.from_records(samples)

  2024-12-16 13:18:38,513 - create_cpds - INFO - PGM creation completed in 0.02447199821472168 seconds

  INFO:create_cpds:PGM creation completed in 0.02447199821472168 seconds

  ```python
  Out[12]:
  {'model': <pgmpy.models.BayesianNetwork.BayesianNetwork at 0x17b36f590>,
   'samples':      N2  N5  N0  N3  N1  N4  N6
   0     1   0   0   0   0   0   2
   1     1   1   0   0   1   1   1
   2     1   1   1   1   0   1   1
   3     1   0   1   1   0   1   2
   4     1   0   1   0   1   1   2
   ..   ..  ..  ..  ..  ..  ..  ..
   995   0   0   1   0   1   1   2
   996   0   1   0   0   1   1   1
   997   1   0   1   1   1   1   3
   998   1   0   0   0   1   1   0
   999   0   0   0   1   1   1   2

   [1000 rows x 7 columns],
   'runtime': 0.02447199821472168}

  In [13]:
  ```



  Please use the following bibtex for citing bng in your research:

  @{mulaudzi2024bng,
    title={bng: Bayesian Network Generator in Python},
    author={Mulaudzi, Rudzani},
    year={2024},
    organization={University of Witwaterand}
  }



  bng is released under MIT License.







  Coming soon. Email rudzani.mulaudzi2@students.wits.ac.za


pkgId: dd22147a771ba8d6271a1d03799ba4d8e6d105390df55eceec5d2001c17559f1
name: python-bayesian-optimization-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for bayesian-optimization
url: https://pypi.org/project/bayesian-optimization/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bayesian-optimization-2.0.2-1.src.rpm
location_href: Packages/python-bayesian-optimization-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
      |  1        | -7.135    |  2.834    |  1.322    |
      |  2        | -7.78     |  2.0      | -1.186    |
      |  3        | -19.0     |  4.0      |  3.0      |
      |  4        | -16.3     |  2.378    | -2.413    |


pkgId: 4e64f4aabfb7fb0936d92d76b6e475fef25e1920e060c67235ccfcb74cd999d9
name: python-bbg-fetch-help
arch: noarch
version: 1.0.30
epoch: 0
release: 1
summary: Development documents and examples for bbg-fetch
url: https://github.com/ArturSepp/BloombergFetch
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bbg-fetch-1.0.30-1.src.rpm
location_href: Packages/python-bbg-fetch-help-1.0.30-1.noarch.rpm
checksum_type: sha256
description:
  Wrapper of xbbg package for bloomberg fetch

  Install using
  ```python
  pip install bbg_fetch
  ```

  Upgrade using
  ```python
  pip install --upgrade bbg_fetch
  ```

  Close using
  ```python
  git clone https://github.com/ArturSepp/BloombergFetch.git
  ```


  Install blpapi package with:
  ```python
  pip install --index-url=https://blpapi.bloomberg.com/repository/releases/python/simple blpapi
  ```

  Configuration of rolls for futures contracts on Bloomberg: GFUT


pkgId: c187c3058077b39600f027c6720c7982607fb60f90375b390b61ed8ff13776b9
name: python-bbot-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for bbot
url: https://github.com/blacklanternsecurity/bbot
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bbot-2.2.0-1.src.rpm
location_href: Packages/python-bbot-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![bbot_banner](https://github.com/user-attachments/assets/f02804ce-9478-4f1e-ac4d-9cf5620a3214)](https://github.com/blacklanternsecurity/bbot)

  [![Python Version](https://img.shields.io/badge/python-3.9+-FF8400)](https://www.python.org) [![License](https://img.shields.io/badge/license-GPLv3-FF8400.svg)](https://github.com/blacklanternsecurity/bbot/blob/dev/LICENSE) [![DEF CON Recon Village 2024](https://img.shields.io/badge/DEF%20CON%20Demo%20Labs-2023-FF8400.svg)](https://www.reconvillage.org/talks) [![PyPi Downloads](https://static.pepy.tech/personalized-badge/bbot?right_color=orange&left_color=grey)](https://pepy.tech/project/bbot) [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![Tests](https://github.com/blacklanternsecurity/bbot/actions/workflows/tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/bbot/actions?query=workflow%3A"tests") [![Codecov](https://codecov.io/gh/blacklanternsecurity/bbot/branch/dev/graph/badge.svg?token=IR5AZBDM5K)](https://codecov.io/gh/blacklanternsecurity/bbot) [![Discord](https://img.shields.io/discord/859164869970362439)](https://discord.com/invite/PZqkgxu5SA)



  https://github.com/blacklanternsecurity/bbot/assets/20261699/e539e89b-92ea-46fa-b893-9cde94eebf81

  _A BBOT scan in real-time - visualization with [VivaGraphJS](https://github.com/blacklanternsecurity/bbot-vivagraphjs)_



  ```bash

  pipx install bbot


  pipx install --pip-args '\--pre' bbot
  ```

  _For more installation methods, including [Docker](https://hub.docker.com/r/blacklanternsecurity/bbot), see [Getting Started](https://www.blacklanternsecurity.com/bbot/Stable/)_





  Passive API sources plus a recursive DNS brute-force with target-specific subdomain mutations.

  ```bash

  bbot -t evilcorp.com -p subdomain-enum


  bbot -t evilcorp.com -p subdomain-enum -rf passive
  ```

  <!-- BBOT SUBDOMAIN-ENUM PRESET EXPANDABLE -->

  <details>
  <summary><b><code>subdomain-enum.yml</code></b></summary>

  ```yaml
  description: Enumerate subdomains via APIs, brute-force

  flags:
    
    - subdomain-enum

  output_modules:
    
    - subdomains

  config:
    dns:
      threads: 25
      brute_threads: 1000
    
    
    
    
    
    
    
    

  ```

  </details>

  <!-- END BBOT SUBDOMAIN-ENUM PRESET EXPANDABLE -->

  BBOT consistently finds 20-50% more subdomains than other tools. The bigger the domain, the bigger the difference. To learn how this is possible, see [How It Works](https://www.blacklanternsecurity.com/bbot/Dev/how_it_works/).

  ![subdomain-stats-ebay](https://github.com/blacklanternsecurity/bbot/assets/20261699/de3e7f21-6f52-4ac4-8eab-367296cd385f)



  ```bash

  bbot -t evilcorp.com -p spider
  ```

  <!-- BBOT SPIDER PRESET EXPANDABLE -->

  <details>
  <summary><b><code>spider.yml</code></b></summary>

  ```yaml
  description: Recursive web spider

  modules:
    - httpx

  config:
    web:
      
      spider_distance: 2
      
      spider_depth: 4
      
      spider_links_per_page: 25

  ```

  </details>

  <!-- END BBOT SPIDER PRESET EXPANDABLE -->



  ```bash

  bbot -t evilcorp.com -p email-enum


  bbot -t evilcorp.com -p email-enum subdomain-enum spider
  ```

  <!-- BBOT EMAIL-ENUM PRESET EXPANDABLE -->

  <details>
  <summary><b><code>email-enum.yml</code></b></summary>

  ```yaml
  description: Enumerate email addresses from APIs, web crawling, etc.

  flags:
    - email-enum

  output_modules:
    - emails

  ```

  </details>

  <!-- END BBOT EMAIL-ENUM PRESET EXPANDABLE -->



  ```bash

  bbot -t www.evilcorp.com -p web-basic


  bbot -t www.evilcorp.com -p web-thorough
  ```

  <!-- BBOT WEB-BASIC PRESET EXPANDABLE -->

  <details>
  <summary><b><code>web-basic.yml</code></b></summary>

  ```yaml
  description: Quick web scan

  include:
    - iis-shortnames

  flags:
    - web-basic

  ```

  </details>

  <!-- END BBOT WEB-BASIC PRESET EXPANDABLE -->

  <!-- BBOT WEB-THOROUGH PRESET EXPANDABLE -->

  <details>
  <summary><b><code>web-thorough.yml</code></b></summary>

  ```yaml
  description: Aggressive web scan

  include:
    
    - web-basic

  flags:
    - web-thorough

  ```

  </details>

  <!-- END BBOT WEB-THOROUGH PRESET EXPANDABLE -->



  ```bash

  bbot -t evilcorp.com -p kitchen-sink


  bbot -t evilcorp.com -p subdomain-enum cloud-enum code-enum email-enum spider web-basic paramminer dirbust-light web-screenshots
  ```

  <!-- BBOT KITCHEN-SINK PRESET EXPANDABLE -->

  <details>
  <summary><b><code>kitchen-sink.yml</code></b></summary>

  ```yaml
  description: Everything everywhere all at once

  include:
    - subdomain-enum
    - cloud-enum
    - code-enum
    - email-enum
    - spider
    - web-basic
    - paramminer
    - dirbust-light
    - web-screenshots
    - baddns-thorough

  config:
    modules:
      baddns:
        enable_references: True



  ```

  </details>

  <!-- END BBOT KITCHEN-SINK PRESET EXPANDABLE -->



  Click the graph below to explore the [inner workings](https://www.blacklanternsecurity.com/bbot/Stable/how_it_works/) of BBOT.

  [![image](https://github.com/blacklanternsecurity/bbot/assets/20261699/e55ba6bd-6d97-48a6-96f0-e122acc23513)](https://www.blacklanternsecurity.com/bbot/Stable/how_it_works/)




  ```python
  from bbot.scanner import Scanner

  if __name__ == "__main__":
      scan = Scanner("evilcorp.com", presets=["subdomain-enum"])
      for event in scan.start():
          print(event)
  ```


  ```python
  from bbot.scanner import Scanner

  async def main():
      scan = Scanner("evilcorp.com", presets=["subdomain-enum"])
      async for event in scan.async_start():
          print(event.json())

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

  <details>
  <summary><b>SEE: This Nefarious Discord Bot</b></summary>

  A [BBOT Discord Bot](https://www.blacklanternsecurity.com/bbot/Stable/dev/#discord-bot-example) that responds to the `/scan` command. Scan the internet from the comfort of your discord server!

  ![bbot-discord](https://github.com/blacklanternsecurity/bbot/assets/20261699/22b268a2-0dfd-4c2a-b7c5-548c0f2cc6f9)

  </details>



  - Support for Multiple Targets
  - Web Screenshots
  - Suite of Offensive Web Modules
  - NLP-powered Subdomain Mutations
  - Native Output to Neo4j (and more)
  - Automatic dependency install with Ansible
  - Search entire attack surface with custom YARA rules
  - Python API + Developer Documentation



  BBOT accepts an unlimited number of targets via `-t`. You can specify targets either directly on the command line or in files (or both!):

  ```bash
  bbot -t evilcorp.com evilcorp.org 1.2.3.0/24 -p subdomain-enum
  ```

  Targets can be any of the following:

  - `DNS_NAME` (`evilcorp.com`)
  - `IP_ADDRESS` (`1.2.3.4`)
  - `IP_RANGE` (`1.2.3.0/24`)
  - `OPEN_TCP_PORT` (`192.168.0.1:80`)
  - `URL` (`https://www.evilcorp.com`)

  For more information, see [Targets](https://www.blacklanternsecurity.com/bbot/Stable/scanning/#targets-t). To learn how BBOT handles scope, see [Scope](https://www.blacklanternsecurity.com/bbot/Stable/scanning/#scope).



  Similar to Amass or Subfinder, BBOT supports API keys for various third-party services such as SecurityTrails, etc.

  The standard way to do this is to enter your API keys in **`~/.config/bbot/bbot.yml`**. Note that multiple API keys are allowed:
  ```yaml
  modules:
    shodan_dns:
      api_key: 4f41243847da693a4f356c0486114bc6
    c99:
      
      api_key:
        - 21a270d5f59c9b05813a72bb41707266
        - ea8f243d9885cf8ce9876a580224fd3c
        - 5bc6ed268ab6488270e496d3183a1a27
    virustotal:
      api_key: dd5f0eee2e4a99b71a939bded450b246
    securitytrails:
      api_key: d9a05c3fd9a514497713c54b4455d0b0
  ```

  If you like, you can also specify them on the command line:
  ```bash
  bbot -c modules.virustotal.api_key=dd5f0eee2e4a99b71a939bded450b246
  ```

  For details, see [Configuration](https://www.blacklanternsecurity.com/bbot/Stable/scanning/configuration/).



  - Complete list of [Modules](https://www.blacklanternsecurity.com/bbot/Stable/modules/list_of_modules/).
  - Complete list of [Flags](https://www.blacklanternsecurity.com/bbot/Stable/scanning/#list-of-flags).
  - Complete list of [Presets](https://www.blacklanternsecurity.com/bbot/Stable/scanning/presets_list/).
      - Complete list of [Global Config Options](https://www.blacklanternsecurity.com/bbot/Stable/scanning/configuration/#global-config-options).
      - Complete list of [Module Config Options](https://www.blacklanternsecurity.com/bbot/Stable/scanning/configuration/#module-config-options).



  <!-- BBOT DOCS TOC -->
  - **User Manual**
      - **Basics**
          - [Getting Started](https://www.blacklanternsecurity.com/bbot/Stable/)
          - [How it Works](https://www.blacklanternsecurity.com/bbot/Stable/how_it_works)
          - [Comparison to Other Tools](https://www.blacklanternsecurity.com/bbot/Stable/comparison)
      - **Scanning**
          - [Scanning Overview](https://www.blacklanternsecurity.com/bbot/Stable/scanning/)
          - **Presets**
              - [Overview](https://www.blacklanternsecurity.com/bbot/Stable/scanning/presets)
              - [List of Presets](https://www.blacklanternsecurity.com/bbot/Stable/scanning/presets_list)
          - [Events](https://www.blacklanternsecurity.com/bbot/Stable/scanning/events)
          - [Output](https://www.blacklanternsecurity.com/bbot/Stable/scanning/output)
          - [Tips and Tricks](https://www.blacklanternsecurity.com/bbot/Stable/scanning/tips_and_tricks)
          - [Advanced Usage](https://www.blacklanternsecurity.com/bbot/Stable/scanning/advanced)
          - [Configuration](https://www.blacklanternsecurity.com/bbot/Stable/scanning/configuration)
      - **Modules**
          - [List of Modules](https://www.blacklanternsecurity.com/bbot/Stable/modules/list_of_modules)
          - [Nuclei](https://www.blacklanternsecurity.com/bbot/Stable/modules/nuclei)
          - [Custom YARA Rules](https://www.blacklanternsecurity.com/bbot/Stable/modules/custom_yara_rules)
      - **Misc**
          - [Contribution](https://www.blacklanternsecurity.com/bbot/Stable/contribution)
          - [Release History](https://www.blacklanternsecurity.com/bbot/Stable/release_history)
          - [Troubleshooting](https://www.blacklanternsecurity.com/bbot/Stable/troubleshooting)
  - **Developer Manual**
      - [Development Overview](https://www.blacklanternsecurity.com/bbot/Stable/dev/)
      - [Setting Up a Dev Environment](https://www.blacklanternsecurity.com/bbot/Stable/dev/dev_environment)
      - [BBOT Internal Architecture](https://www.blacklanternsecurity.com/bbot/Stable/dev/architecture)
      - [How to Write a BBOT Module](https://www.blacklanternsecurity.com/bbot/Stable/dev/module_howto)
      - [Unit Tests](https://www.blacklanternsecurity.com/bbot/Stable/dev/tests)
      - [Discord Bot Example](https://www.blacklanternsecurity.com/bbot/Stable/dev/discord_bot)
      - **Code Reference**
          - [Scanner](https://www.blacklanternsecurity.com/bbot/Stable/dev/scanner)
          - [Presets](https://www.blacklanternsecurity.com/bbot/Stable/dev/presets)
          - [Event](https://www.blacklanternsecurity.com/bbot/Stable/dev/event)
          - [Target](https://www.blacklanternsecurity.com/bbot/Stable/dev/target)
          - [BaseModule](https://www.blacklanternsecurity.com/bbot/Stable/dev/basemodule)
          - [BBOTCore](https://www.blacklanternsecurity.com/bbot/Stable/dev/core)
          - [Engine](https://www.blacklanternsecurity.com/bbot/Stable/dev/engine)
          - **Helpers**
              - [Overview](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/)
              - [Command](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/command)
              - [DNS](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/dns)
              - [Interactsh](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/interactsh)
              - [Miscellaneous](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/misc)
              - [Web](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/web)
              - [Word Cloud](https://www.blacklanternsecurity.com/bbot/Stable/dev/helpers/wordcloud)
  <!-- END BBOT DOCS TOC -->



  Some of the best BBOT modules were written by the community. BBOT is being constantly improved; every day it grows more powerful!

  We welcome contributions. Not just code, but ideas too! If you have an idea for a new feature, please let us know in [Discussions](https://github.com/blacklanternsecurity/bbot/discussions). If you want to get your hands dirty, see [Contribution](https://www.blacklanternsecurity.com/bbot/Stable/contribution/). There you can find setup instructions and a simple tutorial on how to write a BBOT module. We also have extensive [Developer Documentation](https://www.blacklanternsecurity.com/bbot/Stable/dev/).

  Thanks to these amazing people for contributing to BBOT! :heart:

  <p align="center">
  <a href="https://github.com/blacklanternsecurity/bbot/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=blacklanternsecurity/bbot&max=500">
  </a>
  </p>

  Special thanks to:

  - @TheTechromancer for creating BBOT
  - @liquidsec for his extensive work on BBOT's web hacking features, including [badsecrets](https://github.com/blacklanternsecurity/badsecrets) and [baddns](https://github.com/blacklanternsecurity/baddns)
  - Steve Micallef (@smicallef) for creating Spiderfoot
  - @kerrymilan for his Neo4j and Ansible expertise
  - @domwhewell-sage for his family of badass code-looting modules
  - @aconite33 and @amiremami for their ruthless testing
  - Aleksei Kornev (@alekseiko) for granting us ownership of the bbot Pypi repository <3


pkgId: a7878fd17ba533bf9d8f476025f05d7bdc80fd77de5ff48ffb8266f3c68e2cbf
name: python-bboxpy-help
arch: noarch
version: 1.3.2
epoch: 0
release: 1
summary: Development documents and examples for bboxpy
url: https://github.com/cyr-ius/bboxpy
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bboxpy-1.3.2-1.src.rpm
location_href: Packages/python-bboxpy-help-1.3.2-1.noarch.rpm
checksum_type: sha256
description:
  Manage your Bouygues Bbox in Python

  Easily manage your Bbox in Python.
  Check your config, configure your dhcp, disable your wifi, monitor your LAN activity and many others, on LAN or remotely.

  bboxpy is a python library implementing fir the Bbox.

  This project is based on stilllman/aiofreepybox, which provides the same features as aiofreepybox in a synchronous manner.



  Use the PIP package manager

  ```bash
  $ pip install bboxpy
  ```

  Or manually download and install the last version from github

  ```bash
  $ git clone https://github.com/cyr-ius/bboxpy.git
  $ python setup.py install
  ```



  ```python

  from bboxpy import Bbox
  from bboxpy.exceptions import BboxException

  async def async_main()
      
      bbox = Bbox(hostname="https://192.168.1.254",pass='xxxxxx')

      
      await bbox.async_login()

      try:
          device_info = await bbox.device.async_get_bbox_info()
          print(device_info)
      except BboxException as error:
          logger.error(error)

      
      await bbox.device.async_reboot()

      
      await bbox.async_logout()


  if __name__ == "__main__":
      loop = asyncio.get_event_loop()
      loop.run_until_complete(async_main())

  ```


pkgId: 8045487570dd68da08193db74ade5e391b58065e611afedd438ca98eac52279b
name: python-bcdata-help
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Development documents and examples for bcdata
url: https://github.com/smnorris/bcdata
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bcdata-0.14.0-1.src.rpm
location_href: Packages/python-bcdata-help-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
   whse_imagery_and_base_maps.gsr_airports_svw | 2021-02-17 11:50:34.044481-08
  ```

  Search the data listing for airports:
        $ bcdata list | grep AIRPORTS
        WHSE_IMAGERY_AND_BASE_MAPS.GSR_AIRPORTS_SVW
  Describe a dataset. Note that if we know the id of a dataset, we can use that rather than the object name:
      $ bcdata info bc-airports --indent 2
      {
        "name": "WHSE_IMAGERY_AND_BASE_MAPS.GSR_AIRPORTS_SVW",
        "count": 455,
        "schema": {
          "properties": {
            "CUSTODIAN_ORG_DESCRIPTION": "string",
            "BUSINESS_CATEGORY_CLASS": "string",
            "BUSINESS_CATEGORY_DESCRIPTION": "string",
            "OCCUPANT_TYPE_DESCRIPTION": "string",
          },
          "geometry": "GeometryCollection",
          "geometry_column": "SHAPE"
        }
      }
  The JSON output can be manipulated with [jq](https://stedolan.github.io/jq/). For example, to show only the fields available in the dataset:
      $ bcdata info bc-airports | jq '.schema'
      {
        "CUSTODIAN_ORG_DESCRIPTION": "string",
        "BUSINESS_CATEGORY_CLASS": "string",
        "BUSINESS_CATEGORY_DESCRIPTION": "string",
        "OCCUPANT_TYPE_DESCRIPTION": "string",
        etc...
      }
  Dump data to geojson ([`EPSG:4326` only](https://tools.ietf.org/html/rfc7946#section-4)):
      $ bcdata dump bc-airports > bc-airports.geojson
  Get a single feature and send it to geojsonio (requires [geojson-cli](https://github.com/mapbox/geojsonio-cli)).  Note the double quotes  required around a CQL FILTER provided to the `--query` option.
      $ bcdata dump \
        WHSE_IMAGERY_AND_BASE_MAPS.GSR_AIRPORTS_SVW \
        --query "AIRPORT_NAME='Terrace (Northwest Regional) Airport'" \
         | geojsonio
  Save a layer to a geopackage in BC Albers:
      $ bcdata cat bc-airports --dst-crs EPSG:3005 \
        | fio collect \
        | fio load -f GPKG --dst-crs EPSG:3005 airports.gpkg
  Note that this will not work if the source data has mixed geometry types.
  Load to parquet on s3:
      $ bcdata dump bc-airports \
        | ogr2ogr -f Parquet /vsis3/$BUCKET/airports.parquet -s_srs EPSG:4326 -t_srs EPSG:3005 /vsistdin/
  Load data to postgres and run a spatial query:
      $ bcdata bc2pg bc-airports \
          --db_url postgresql://postgres:postgres@localhost:5432/postgis
      $ bcdata bc2pg WHSE_LEGAL_ADMIN_BOUNDARIES.ABMS_MUNICIPALITIES_SP \
          --db_url postgresql://postgres:postgres@localhost:5432/postgis
      $ psql -c \
        "SELECT airport_name
         FROM whse_imagery_and_base_maps.gsr_airports_svw a
         INNER JOIN whse_legal_admin_boundaries.abms_municipalities_sp m
         ON ST_Intersects(a.geom, m.geom)
         WHERE admin_area_name LIKE '%Victoria%'"


pkgId: e93bd19ff11261aa9d1b71559eeec8730a346c94353a71c9199e038140f4fa75
name: python-bcf-api-xml-help
arch: noarch
version: 0.4.14
epoch: 0
release: 1
summary: Development documents and examples for bcf-api-xml
url: https://github.com/bimdata/BCF-API-XML-translator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bcf-api-xml-0.4.14-1.src.rpm
location_href: Packages/python-bcf-api-xml-help-0.4.14-1.noarch.rpm
checksum_type: sha256
description:
  BCF-API-XML-converter is a library to open BCFzip and get data similar to BCF API json and to save BCF API data as BCFzip files.

  ```bash
  pip install bcf-api-xml
  ```

  ```python
      from bcf_api_xml import to_zip, to_json
      file_like_bcf_zip = to_zip(topics, comments, viewpoints)
      imported_topics = to_json(file_like_bcf_zip)
  ```

  ```bash
  poetry shell
  poetry install
  pytest
  pre-commit install
  ```

  ```bash
  poetry publish --build --username= --password=
  ```


pkgId: 73472bd9278801ec722da69c25f2c0ead8f8da4b159467616da89a11c5986dd1
name: python-bcpandas-help
arch: noarch
version: 2.7.2
epoch: 0
release: 1
summary: Development documents and examples for bcpandas
url: https://pypi.org/project/bcpandas/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bcpandas-2.7.2-1.src.rpm
location_href: Packages/python-bcpandas-help-2.7.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/bcpandas.svg)](https://pypi.org/project/bcpandas/)
  [![Conda-Forge version](https://img.shields.io/conda/vn/conda-forge/bcpandas.svg)](https://anaconda.org/conda-forge/bcpandas)
  [![GitHub license](https://img.shields.io/github/license/yehoshuadimarsky/bcpandas.svg)](https://github.com/yehoshuadimarsky/bcpandas/blob/master/LICENSE)
  [![CI](https://github.com/yehoshuadimarsky/bcpandas/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/yehoshuadimarsky/bcpandas/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/yehoshuadimarsky/bcpandas/branch/master/graph/badge.svg)](https://codecov.io/gh/yehoshuadimarsky/bcpandas)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/bcpandas.svg)](https://pypi.python.org/pypi/bcpandas/)
  [![Awesome Badges](https://img.shields.io/badge/badges-awesome-green.svg)](https://github.com/Naereen/badges)
  [![Downloads](https://static.pepy.tech/personalized-badge/bcpandas?period=total&units=international_system&left_color=grey&right_color=orange&left_text=pypi%20total%20downloads)](https://pepy.tech/project/bcpandas)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/yehoshuadimarsky/bcpandas/master.svg)](https://results.pre-commit.ci/latest/github/yehoshuadimarsky/bcpandas/master)

  High-level wrapper around BCP for high performance data transfers between pandas and SQL Server. No
  knowledge of BCP required!! (pronounced _BEE-CEE-Pandas_)

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

  - [Quickstart](#quickstart)
  - [IMPORTANT - Read vs. Write](#important---read-vs-write)
  - [Benchmarks](#benchmarks)
    - [to_sql](#to_sql)
      - [Why not just use the new pandas `method='multi'`?](#why-not-just-use-the-new-pandas-methodmulti)
    - [read_sql](#read_sql)
  - [Requirements](#requirements)
    - [Database](#database)
    - [Python User](#python-user)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Credential/Connection object](#credentialconnection-object)
    - [Recommended Usage](#recommended-usage)
  - [Known Issues](#known-issues)
    - [Troubleshooting](#troubleshooting)
      - [All quote characters appear in the data](#all-quote-characters-appear-in-the-data)
      - [All delimiter characters appear in the data](#all-delimiter-characters-appear-in-the-data)
      - [Write to database fails due to spaces in columns](#write-to-database-fails-due-to-spaces-in-columns)
  - [Background](#background)
    - [Existing Solutions](#existing-solutions)
    - [Design and Scope](#design-and-scope)
  - [Testing](#testing)
    - [Testing Requirements](#testing-requirements)
    - [What Is Tested?](#what-is-tested)
    - [Testing Implementation](#testing-implementation)
  - [CI/CD](#cicd)
  - [Contributing](#contributing)
  - [GitHub Stars Trend](#github-stars-trend)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->



  ```python
  In [1]: import pandas as pd
     ...: import numpy as np
     ...:
     ...: from bcpandas import SqlCreds, to_sql

  In [2]: creds = SqlCreds(
     ...:     'my_server',
     ...:     'my_db',
     ...:     'my_username',
     ...:     'my_password'
     ...: )

  In [3]: df = pd.DataFrame(
     ...:         data=np.ndarray(shape=(10, 6), dtype=int),
     ...:         columns=[f"col_{x}" for x in range(6)]
     ...:     )

  In [4]: df
  Out[4]:
       col_0    col_1    col_2    col_3    col_4    col_5
  0  4128860  6029375  3801155  5570652  6619251  7536754
  1  4849756  7536751  4456552  7143529  7471201  7012467
  2  6029433  6881357  6881390  7274595  6553710  3342433
  3  6619228  7733358  6029427  6488162  6357104  6553710
  4  7536737  7077980  6422633  7536732  7602281  2949221
  5  6357104  7012451  6750305  7536741  7340124  7274610
  6  7340141  6226036  7274612  7077999  6881387  6029428
  7  6619243  6226041  6881378  6553710  7209065  6029415
  8  6881378  6553710  7209065  7536743  7274588  6619248
  9  6226030  7209065  6619231  6881380  7274612  3014770

  In [5]: to_sql(df, 'my_test_table', creds, index=False, if_exists='replace')

  In [6]: df2 = pd.read_sql_table(table_name='my_test_table', con=creds.engine)

  In [7]: df2
  Out[7]:
       col_0    col_1    col_2    col_3    col_4    col_5
  0  4128860  6029375  3801155  5570652  6619251  7536754
  1  4849756  7536751  4456552  7143529  7471201  7012467
  2  6029433  6881357  6881390  7274595  6553710  3342433
  3  6619228  7733358  6029427  6488162  6357104  6553710
  4  7536737  7077980  6422633  7536732  7602281  2949221
  5  6357104  7012451  6750305  7536741  7340124  7274610
  6  7340141  6226036  7274612  7077999  6881387  6029428
  7  6619243  6226041  6881378  6553710  7209065  6029415
  8  6881378  6553710  7209065  7536743  7274588  6619248
  9  6226030  7209065  6619231  6881380  7274612  3014770
  ```



  The big speedup benefit of bcpandas is in the `to_sql` function, as the benchmarks below show.
  However, the bcpandas `read_sql` function actually performs **slower** than the pandas equivalent.
  Therefore, the bcpandas `read_sql` function was deprecated in v5.0 and has now been removed in
  v6.0+. To read data **from** SQL to pandas, use the native pandas method `pd.read_sql_table` or
  `pd.read_sql_query`.



  See figures below. All code is in the `/benchmarks` directory. To run the benchmarks, from the root
  directory of this repository, run `python benchmarks/benchmark.py main --help` and fill in the
  command line options that are presented.

  Running this will output

  1. PNG image of the graph
  2. JSON file of the benchmark data
  3. JSON file with the environment details of the machine that was used to generate it



  > I didn't bother including the pandas non-`multiinsert` version here because it just takes way too
  > long

  ![to_sql benchmark graph](benchmarks/tosql_benchmark.png)



  1. Because it is still much slower
  2. Because you are forced to set the `chunksize` parameter to a very small number for it to work -
     generally a bit less then `2100/<number of columns>`. This is because SQL Server can only accept
     up to 2100 parameters in a query. See
     [here](https://stackoverflow.com/questions/50689082/to-sql-pyodbc-count-field-incorrect-or-syntax-error)
     and [here](https://github.com/mkleehammer/pyodbc/issues/217) for more discussion on this, and
     the recommendation to use a bulk insert tool such as BCP. It seems that SQL Server simply didn't
     design the regular `INSERT` statement to support huge amounts of data.



  As you can see, pandas native clearly wins here

  ![read_sql benchmark graph](benchmarks/readsql_benchmark.png)





  Any version of Microsoft SQL Server. Can be installed on-prem, in the cloud, on a VM, or one of the
  Azure versions.



  - [BCP](https://docs.microsoft.com/en-us/sql/tools/bcp-utility) Utility
  - Microsoft ODBC Driver **11, 13, 13.1, or 17** for SQL Server.
    ([Microsoft Docs](https://docs.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server))
    See the
    [pyodbc docs](https://github.com/mkleehammer/pyodbc/wiki/Connecting-to-SQL-Server-from-Windows)
    for more on different driver versions.
  - Python >= 3.9
  - `pandas` >= 2.1.2
  - `sqlalchemy` >= 1.4
  - `pyodbc` as the
    [supported DBAPI](https://docs.sqlalchemy.org/en/13/dialects/mssql.html#module-sqlalchemy.dialects.mssql.pyodbc)



  | Source |                 Command                 |
  | :----: | :-------------------------------------: |
  |  PyPI  |         `pip install bcpandas`          |
  | Conda  | `conda install -c conda-forge bcpandas` |



  1. Create creds (see next section)
  2. Replace any `df.to_sql(...)` in your code with `bcpandas.to_sql(df, ...)`

  That's it!



  Bcpandas requires a `bcpandas.SqlCreds` object in order to use it, and also a `sqlalchemy.Engine`.
  The user has 2 options when constructing it.

  1. Create the bcpandas `SqlCreds` object with just the minimum attributes needed (server, database,
     username, password), and bcpandas will create a full `Engine` object from this. It will use
     `pyodbc`, `sqlalchemy`, and the Microsoft ODBC Driver for SQL Server, and will store it in the
     `.engine` attribute.

     ```python
     In [1]: from bcpandas import SqlCreds

     In [2]: creds = SqlCreds('my_server', 'my_db', 'my_username', 'my_password')

     In [3]: creds.engine
     Out[3]: Engine(mssql+pyodbc:///?odbc_connect=Driver={ODBC Driver 17 for SQL Server};Server=tcp:my_server,1433;Database=my_db;UID=my_username;PWD=my_password)

     ```

  2. Pass a full `Engine` object to the bcpandas `SqlCreds` object, and bcpandas will attempt to
     parse out the server, database, username, and password to pass to the command line utilities. If
     a DSN is used, this will fail.

     (continuing example above)

     ```python
     In [4]: creds2 = SqlCreds.from_engine(creds.engine)

     In [5]: creds2.engine
     Out[5]: Engine(mssql+pyodbc:///?odbc_connect=Driver={ODBC Driver 17 for SQL Server};Server=tcp:my_server,1433;Database=my_db;UID=my_username;PWD=my_password)

     In [6]: creds2
     Out[6]: SqlCreds(server='my_server', database='my_db', username='my_username', with_krb_auth=False, engine=Engine(mssql+pyodbc:///?odbc_connect=Driver={ODBC Driver 17 for SQL Server};Server=tcp:my_server,1433;Database=my_db;UID=my_username;PWD=my_password), password=[REDACTED])
     ```



  | Feature                                           |   Pandas native    |      BCPandas      |
  | ------------------------------------------------- | :----------------: | :----------------: |
  | Super speed                                       |        :x:         | :white_check_mark: |
  | Good for simple data types like numbers and dates |        :x:         | :white_check_mark: |
  | Handle messy string data                          | :white_check_mark: |        :x:         |

  > built with the help of https://www.tablesgenerator.com/markdown_tables# and
  > https://gist.github.com/rxaviers/7360908



  Here are some caveats and limitations of bcpandas.

  - Bcpandas has been tested with all ASCII characters 32-127. Unicode characters beyond that range
    have not been tested.
  - An empty string (`""`) in the dataframe becomes `NULL` in the SQL database instead of remaining
    an empty string.
  - Because bcpandas first outputs to CSV, it needs to use several specific characters to create the
    CSV, including a _delimiter_ and a _quote character_. Bcpandas attempts to use characters that
    are not present in the dataframe for this, going through the possilbe delimiters and quote
    characters specified in `constants.py`. If all possible characters are present in the dataframe
    and bcpandas cannot find both a delimiter and quote character to use, it will throw an error.
    - The BCP utility does **not** ignore delimiter characters when surrounded by quotes, unlike
      CSVs - see
      [here](https://docs.microsoft.com/en-us/sql/relational-databases/import-export/specify-field-and-row-terminators-sql-server#characters-supported-as-terminators)
      in the Microsoft docs.
  - ~~If there is a NaN/Null in the last column of the dataframe it will throw an error. This is due
    to a BCP issue. See my issue with Microsoft about this
    [here](https://github.com/MicrosoftDocs/sql-docs/issues/2689).~~ This doesn't seem to be a
    problem based on the tests.





  If you encounter the error:
  ```
  bcpandas.constants.BCPandasValueError: Data contains all of the possible quote characters ('"', "'", '`', '~'),
  cannot use BCP to import it. Replace one of the possible quote characters in
  your data, or use another method besides bcpandas.
  ```

  And want to still use BCPandas, you will need to pick a quote character and remove all instances of it from the dataframe.  Note
  that you are modifying your data and take care that replacing e.g., the `~` character will not have undesired consequences.

  In this case we are looking to remove `~`, replacing it with `-`.  Hunt for its presence in a column:
  ```
  my_df['some_text_column'].str.contains('~').sum()
  ```
  If that returns a value greater than zero, you can perform replacement in that column like this:
  ```
  my_df['some_text_column'] = my_df['some_text_column'].str.replace('~','-')
  ```
  Then use the first command to confirm that the number of occurences is now 0.



  Very similar to above, but with the error message:
  ```
  bcpandas.constants.BCPandasValueError: Data contains all of the possible delimiter characters (',', '|', '\t'),
  cannot use BCP to import it. Replace one of the possible delimiter characters in
  your data, or use another method besides bcpandas.
  ```

  Approach this as is described above for quote characters.  If you target the `|` character for replacement, note that it
  must be escaped in a regular expression with a backslash.  So the relevant commands would be (here the pipe `|` is replaced with a front slash):
  ```
  my_df['some_text_column'] = my_df['some_text_column'].str.replace('\|','/')
  my_df['some_text_column'].str.contains('\|').sum()
  ```



  If you get this error message when writing to the database:
  ```
  Error = [Microsoft][ODBC Driver 17 for SQL Server]Incorrect host-column number found in BCP format-file
  ```
  Try replacing any space characters in your column names, with a command like `my_df.columns = my_df.columns.str.replace(' ','_')` ([source](https://github.com/yehoshuadimarsky/bcpandas/issues/30)).



  Writing data from pandas DataFrames to a SQL database is very slow using the built-in `to_sql`
  method, even with the newly introduced
  [`execute_many`](https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#io-sql-method)
  option. For Microsoft SQL Server, a far far faster method is to use the BCP utility provided by
  Microsoft. This utility is a command line tool that transfers data to/from the database and flat
  text files.

  This package is a wrapper for seamlessly using the bcp utility from Python using a pandas
  DataFrame. Despite the IO hits, the fastest option by far is saving the data to a CSV file in the
  file system and using the bcp utility to transfer the CSV file to SQL Server. **Best of all, you
  don't need to know anything about using BCP at all!**



  > Much credit is due to `bcpy` for the original idea and for some of the code that was adopted and
  > changed.

  <details>
    <summary>bcpy</summary>

  [bcpy](https://github.com/titan550/bcpy) has several flaws:

  - No support for reading from SQL, only writing to SQL
  - A convoluted, overly class-based internal design
  - Scope a bit too broad - deals with pandas as well as flat files This repository aims to fix and
  improve on `bcpy` and the above issues by making the design choices described earlier.
  </details>



  The _**only**_ scope of `bcpandas` is to read and write between a pandas DataFrame and a Microsoft
  SQL Server database. That's it. We do _**not**_ concern ourselves with reading existing flat files
  to/from SQL - that introduces _way_ to much complexity in trying to parse and decode the various
  parts of the file, like delimiters, quote characters, and line endings. Instead, to read/write an
  exiting flat file, just import it via pandas into a DataFrame, and then use `bcpandas`.

  The big benefit of this is that we get to precicely control all the finicky parts of the text file
  when we write/read it to a local file and then in the BCP utility. This lets us set library-wide
  defaults (maybe configurable in the future) and work with those.

  For now, we are using the non-XML BCP format file type. In the future, XML format files may be
  added.





  - Docker Desktop installed, either of the Linux or Windows runtimes, doesn't matter
  - pytest
  - hypothesis
  - pytest-cov (coverage.py)



  We take testing very seriously here. In order to rely on a library like this in production, it
  **MUST** be ruthlessly tested, which thankfully it is. Here is a partial list of what has been
  tested so far. Pull Requests welcome!

  - Data types: All ASCII characters 32-127 (using the Hypothesis library, see below). Unicode
    characters beyond that range have not been tested.
  - `numpy.NaN`, `None`
  - `numpy.inf` (fails, as expected)
  - Empty dataframe (nothing happens, database not modified)
  - Duplicate column names (raises error)
  - Database columns that are missing from the dataframe, are out of order, or both (passes)
  - Extra dataframe columns that aren't in database, when `if_exists="append"` specified (fails)



  - Testing uses `pytest`.
  - To test for all possible data types, we use the `hypothesis` library, instead of trying to come
    up with every single case on our own.
  - `pytest-cov` (which uses `coverage.py` under the hood) is used to measure code coverage. This is
    then uploaded to [codecov.io](https://codecov.io/gh/yehoshuadimarsky/bcpandas) as part of the
    CI/CD process (see below).
  - In order to spin up a local SQL Server during testing, we use Docker. Specifically, we run one of
    the images that Microsoft provides that already have SQL Server fully installed, all we have to
    do is use the image to run a container. Here are the links to the
    [Linux versions](https://hub.docker.com/_/microsoft-mssql-server) and the Windows versions -
    [Express](https://hub.docker.com/r/microsoft/mssql-server-windows-express/) and
    [Developer](https://hub.docker.com/r/microsoft/mssql-server-windows-developer).
    - When running the tests, we can specify a specific Docker image to use, by invoking the custom
      command line option called `--mssql-docker-image`. For example:
      ```bash
      pytest bcpandas/tests --mssql-docker-image mcr.microsoft.com/mssql/server:2019-latest
      ```
  - Instead of using the `subprocess` library to control Docker manually, we use the elegant
    `docker-py` library which works very nicely. A `DockerDB` Python class is defined in
    `bcpandas/tests/utils.py` and it wraps up all the Docker commands and functionality needed to use
    SQL Server into one class. This class is used in `conftest.py` in the core bcpandas tests, and in
    the `benchmarks/` directory for both the benchmarks code as well as the legacy tests for
    `read_sql`.



  Github Actions is used for CI/CD, although it is still somewhat a work in progress.



  Please, all contributions are very welcome!

  I will attempt to use the `pandas` docstring style as detailed
  [here](https://pandas.pydata.org/pandas-docs/stable/development/contributing_docstring.html).



  [![Stargazers over time](https://starchart.cc/yehoshuadimarsky/bcpandas.svg)](https://starchart.cc/yehoshuadimarsky/bcpandas)


pkgId: da8caccd2339725d12d32b1ee38ca551fecf2e05e4abc85c6517e8415fbaefd0
name: python-bdd100-to-yolo-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for bdd100-to-yolo
url: https://pypi.org/project/bdd100-to-yolo/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bdd100-to-yolo-0.0.2-1.src.rpm
location_href: Packages/python-bdd100-to-yolo-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Invert bdd100 dataset to yolo dataset and fix dataset

  pip install bdd100-to-yolo

  <pre><code>#import modules
  from bdd100_to_yolo import bdd100_to_yolo


  images_train_path = "bd100/images/train"
  images_val_path = "bdd100/images/val"
  labels_train_path = "bdd100_labels/det_train.json"
  labels_val_path = "bdd100_labels/det_val.json"
  labels_train_save_path = "bdd100/labels/train"
  labels_val_save_path = "bdd100/labels/val"

  '''
  It is feasible to delete some lables you do not want or shuffle the list below,
  "pederstrain" corresponds class number 0, "car" corresponds class number 1 and the next follws the same rules as above.
  '''
  classes = [
      "pedestrian",
      
      "car",
      "truck",
      
      
      "motorcycle",
      "bicycle",
      "traffic light",
      "traffic sign"
  ]


  bdd100_to_yolo.dataset_invert(images_train_path, labels_train_path, labels_train_save_path, classes)
  bdd100_to_yolo.dataset_invert(images_val_path, labels_val_path, labels_val_save_path, classes)

  '''
  Some image files may not have corresponding label files,
  so it is necessary to clear the invalid data.
  Warning that you must invert all dbb100 json files to yolo txt file at first and then fixing the dataset.
  BDD100K has 10 000 images so it may take 1 - 3 hours to fix the dataset.
  '''
  bdd100_to_yolo.dataset_fix(images_train_path, labels_train_save_path)
  bdd100_to_yolo.dataset_fix(images_val_path, labels_val_save_path)</code></pre>

rpm_license:
  MIT License  Copyright (c) 2024 Tom  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: 974fdd778901a930ab0bc2a5f00a4a484950d8d93707905b344d13b715912b84
name: python-bdext-help
arch: noarch
version: 0.1.16
epoch: 0
release: 1
summary: Development documents and examples for bdext
url: https://github.com/evolbioinfo/bdpn
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bdext-0.1.16-1.src.rpm
location_href: Packages/python-bdext-help-0.1.16-1.noarch.rpm
checksum_type: sha256
description:
  Estimator of BD-PN model parameters from phylogenetic trees and a non-parametric PN detection test.



  [//]: # ([![DOI:10.1093/sysbio/syad059]&#40;https://zenodo.org/badge/DOI/10.1093/sysbio/syad059.svg&#41;]&#40;https://doi.org/10.1093/sysbio/syad059&#41;)
  [//]: # ([![GitHub release]&#40;https://img.shields.io/github/v/release/evolbioinfo/bdpn.svg&#41;]&#40;https://github.com/evolbioinfo/bdpn/releases&#41;)
  [![PyPI version](https://badge.fury.io/py/bdpn.svg)](https://pypi.org/project/bdpn/)
  [![PyPI downloads](https://shields.io/pypi/dm/bdpn)](https://pypi.org/project/bdpn/)
  [![Docker pulls](https://img.shields.io/docker/pulls/evolbioinfo/bdpn)](https://hub.docker.com/r/evolbioinfo/bdpn/tags)



  BD-PN model extends the classical birth-death (BD) model with incomplete sampling [[Stadler 2009]](https://pubmed.ncbi.nlm.nih.gov/19631666/), by adding partner notification (PN).
  Under this model, infected individuals can transmit their pathogen with a constant rate λ,
  get removed (become non-infectious) with a constant rate ψ,
  and their pathogen can be sampled upon removal
  with a constant probability ρ. On top of that, in the BD-PN model,
  at the moment of sampling the sampled individual
  might notify their most recent partner with a constant probability υ.
  Upon notification, the partner is removed almost instantaneously (modeled via a constant notified
  removal rate φ >> ψ) and their pathogen is sampled.

  BD-PN model therefore has 5 parameters:
  * λ -- transmission rate
  * ψ -- removal rate
  * ρ -- sampling probability upon removal
  * υ -- probability to notify the last partner upon sampling
  * φ -- removal (and sampling) rate after notification

  These parameters can be expressed in terms of the following epidemiological parameters:
  * R<sub>0</sub>=λ/ψ -- reproduction number
  * 1/ψ -- infectious time
  * 1/φ -- partner removal time

  BD-PN model makes 3 assumptions:
  1. only observed individuals can notify (instead of any removed individual);
  2. notified individuals are always observed upon removal;
  3. only the most recent partner can get notified.

  For identifiability, BD-PN model requires one of the three BD model parameters (λ, ψ, ρ) to be fixed.



  The bdpn package provides a classical BD and a BD-PN model maximum-likelihood parameter estimator
  from a user-supplied time-scaled phylogenetic tree.
  User must also provide a value for one of the three BD model parameters (λ, ψ, or ρ).
  We recommend providing the sampling probability ρ,
  which could be estimated as the number of tree tips divided by the number of declared cases for the same time period.



  The bdpn package provides a non-parametric test detecting presence/absence of partner notification in a user-supplied time-scaled phylogenetic tree.
  It outputs a p-value.


  One needs to supply a time-scaled phylogenetic tree in newick format.
  In the examples below we will use an HIV tree reconstructed from 200 sequences,
  published in [[Rasmussen _et al._ PLoS Comput. Biol. 2017]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1005448),
  which you can find at [PairTree GitHub](https://github.com/davidrasm/PairTree)
  and in [hiv_zurich/Zurich.nwk](hiv_zurich/Zurich.nwk).



  There are 4 alternative ways to run __bdpn__ on your computer:
  with [docker](https://www.docker.com/community-edition),
  [apptainer](https://apptainer.org/),
  in Python3, or via command line (requires installation with Python3).





  You could either install python (version 3.9 or higher) system-wide and then install bdpn via pip:
  ```bash
  sudo apt install -y python3 python3-pip python3-setuptools python3-distutils
  pip3 install bdpn
  ```

  or alternatively, you could install python (version 3.9 or higher) and bdpn via [conda](https://conda.io/docs/) (make sure that conda is installed first).
  Here we will create a conda environment called _bdpnenv_:
  ```bash
  conda create --name bdpnenv python=3.9
  conda activate bdpnenv
  pip install bdpn
  ```



  If you installed __bdpn__ in a conda environment (here named _bdpnenv_), do not forget to first activate it, e.g.

  ```bash
  conda activate bdpnenv
  ```

  Run the following commands to check for the presence of partner notification and estimate BD-PN model parameters.
  The first command applies the PN test to a tree Zurich.nwk and saves the PN-test value to the file cherry_test.txt
  The second command estimated the BD-PN parameters and their 95% CIs for this tree, assuming the sampling probability of 0.25,
  and saves the estimated parameters to a comma-separated file estimates_bdpn.csv.
  The third command estimated the classical BD parameters and their 95% CIs for this tree, assuming the sampling probability of 0.25,
  and saves the estimated parameters to a comma-separated file estimates_bd.csv.
  ```bash
  pn_test --nwk Zurich.nwk --log cherry_test.txt
  bdpn_infer --nwk Zurich.nwk --ci --p 0.25 --log estimates_bdpn.csv
  bd_infer --nwk Zurich.nwk --ci --p 0.25 --log estimates_bd.csv
  ```



  To see detailed options, run:
  ```bash
  pn_test --help
  bdpn_infer --help
  bd_infer --help
  ```





  Once [docker](https://www.docker.com/community-edition) is installed,
  run the following command to estimate BD-PN model parameters:
  ```bash
  docker run -v <path_to_the_folder_containing_the_tree>:/data:rw -t evolbioinfo/bdpn --nwk /data/Zurich.nwk --ci --p 0.25 --log /data/estimates.csv
  ```

  This will produce a comma-separated file estimates.csv in the <path_to_the_folder_containing_the_tree> folder,
   containing the estimated parameter values and their 95% CIs (can be viewed with a text editor, Excel or Libre Office Calc).



  To see advanced options, run
  ```bash
  docker run -t evolbioinfo/bdpn -h
  ```






  Once [apptainer](https://apptainer.org/docs/user/latest/quick_start.html#installation) is installed,
  run the following command to estimate BD-PN model parameters (from the folder where the Zurich.nwk tree is contained):

  ```bash
  apptainer run docker://evolbioinfo/bdpn --nwk Zurich.nwk --ci --p 0.25 --log estimates.csv
  ```

  This will produce a comma-separated file estimates.csv,
   containing the estimated parameter values and their 95% CIs (can be viewed with a text editor, Excel or Libre Office Calc).




  To see advanced options, run
  ```bash
  apptainer run docker://evolbioinfo/bdpn -h
  ```


pkgId: db3c01a2ad2d4a332b8ae229934357b14c2f21533d1fc583f656d226176ab60b
name: python-beancount-stubs-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for beancount-stubs
url: https://pypi.org/project/beancount-stubs/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beancount-stubs-0.1.5-1.src.rpm
location_href: Packages/python-beancount-stubs-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/jmgilman/beancount-stubs/actions/workflows/ci.yml">
          <img src="https://github.com/jmgilman/beancount-stubs/actions/workflows/ci.yml/badge.svg"/>
      </a>
      <a href="https://pypi.org/project/beancount-stubs">
          <img src="https://img.shields.io/pypi/v/beancount-stubs"/>
      </a>
  </p>

  > A package containing stub files for the [beancount][1] package.



  Install the package:

  ```shell
  $> pip install beancount-stubs
  ```

  Run `mypy`:

  ```shell
  $> mypy .
  ```

  The `mypy` binary will automatically detect the stubs included in the installed
  package and use them when asserting against the beancount package. Note that
  many of the subpackages in the beancount package do not have stubs and `mypy`
  will complain about the missing stubs. To disable this error on an unsupported
  package, use the following syntax:

  ```python
  from beancount.ops import validation  # type: ignore
  ```



  The following subpackages/modules are currently supported:

  * `beancount.loader`
  * `beancount.core.*`
  * `beancount.query.numberify`
  * `beancount.query.query`
  * `beancount.query.query_compile`
  * `beancount.query.query_execute`



  Check out the [issues][2] for items needing attention or submit your own and
  then:

  1. [Fork the repo](https://github.com/jmgilman/beancount-stubs/fork)
  2. Create your feature branch (git checkout -b feature/fooBar)
  3. Commit your changes (git commit -am 'Add some fooBar')
  4. Push to the branch (git push origin feature/fooBar)
  5. Create a new Pull Request

  [1]: https://github.com/beancount/beancount
  [2]: https://github.com/jmgilman/beancount-stubs/issues

rpm_license:
  Copyright 2022 Joshua Gilman  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: 5806e3c37bfe5d28827c4ec21e2dec71358acc329fe5bc035f64be87076c5078
name: python-beaupy-help
arch: noarch
version: 3.10.0
epoch: 0
release: 1
summary: Development documents and examples for beaupy
url: https://github.com/petereon/beaupy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beaupy-3.10.0-1.src.rpm
location_href: Packages/python-beaupy-help-3.10.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/petereon/beaupy/actions/workflows/python-test.yml/badge.svg)](https://github.com/petereon/beaupy/actions/workflows/python-test.yml)
  [![codecov](https://codecov.io/gh/petereon/beaupy/branch/master/graph/badge.svg?token=HSG6MGTXBC)](https://codecov.io/gh/petereon/beaupy)
  [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=petereon_beaupy&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=petereon_beaupy)
  [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=petereon_beaupy&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=petereon_beaupy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/beaupy?color=g&label=%F0%9F%93%A5%20Downloads)
  ![example](https://raw.githubusercontent.com/petereon/beaupy/master/example.gif)
  For documentation but more and prettier see [**here**](https://petereon.github.io/beaupy/)

  BeauPy stands on the shoulders of giants. It is based on another library with which it shares some of the source code, [`cutie`](https://github.com/kamik423/cutie), developed by [Kamik423](https://github.com/Kamik423). It has begun as a fork but has since diverged into its own thing and as such, detached from the original repository.

  **BeauPy** implements a number of common interactive elements:
  | Function                                                                         | Functionality                                                                              |
  |:---------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------------|
  | [`select`](https://petereon.github.io/beaupy/api/#select)                        | Prompt to pick a choice from a list                                                        |
  | [`select_multiple`](https://petereon.github.io/beaupy/api/#select_multiple)      | Prompt to select one or multiple choices from a list                                       |
  | [`confirm`](https://petereon.github.io/beaupy/api/#confirm)                      | Prompt with a question and yes/no options                                                  |
  | [`prompt`](https://petereon.github.io/beaupy/api/#prompt)                        | Prompt that takes free input with optional validation, type conversion and input hiding    |
  TUI elements shown in the above gif are the result of the following code:
  ```python
  import time
  from beaupy import confirm, prompt, select, select_multiple
  from beaupy.spinners import *
  from rich.console import Console
  console = Console()

  if confirm("Will you take the ring to Mordor?"):
      names = [
          "Frodo Baggins",
          "Samwise Gamgee",
          "Legolas",
          "Aragorn",
          "[red]Sauron[/red]",
      ]
      console.print("Who are you?")
      
      name = select(names, cursor="🢧", cursor_style="cyan")
      console.print(f"Alámenë, {name}")
      item_options = [
          "The One Ring",
          "Dagger",
          "Po-tae-toes",
          "Lightsaber (Wrong franchise! Nevermind, roll with it!)",
      ]
      console.print("What do you bring with you?")
      
      items = select_multiple(item_options, tick_character='🎒', ticked_indices=[0], maximal_count=3)
      potato_count = 0
      if "Po-tae-toes" in items:
          
          potato_count = prompt('How many potatoes?', target_type=int, validator=lambda count: count > 0)
      
      spinner = Spinner(DOTS, "Packing things...")
      spinner.start()
      time.sleep(2)
      spinner.stop()
      
      if "friend" == prompt("Speak, [blue bold underline]friend[/blue bold underline], and enter", secure=True).lower():
          
          spinner_animation = ['▉▉', '▌▐', '  ', '▌▐', '▉▉']
          spinner = Spinner(spinner_animation, "Opening the Door of Durin...")
          spinner.start()
          time.sleep(2)
          spinner.stop()
      else:
          spinner_animation = ['🐙🌊    ⚔️ ', '🐙 🌊   ⚔️ ', '🐙  🌊  ⚔️ ', '🐙   🌊 ⚔️ ', '🐙    🌊⚔️ ']
          spinner = Spinner(spinner_animation, "Getting attacked by an octopus...")
          spinner.start()
          time.sleep(2)
          spinner.stop()
      if 'The One Ring' in items:
          console.print("[green]You throw The One Ring to a lava from an eagle![/green]")
      else:
          console.print("[red]You forgot the ring and brought Middle-Earth to its knees![/red]")
      console.print(f"And you brought {potato_count} taters!")
  ```
  For more information refer to [more examples](https://petereon.github.io/beaupy/examples/) or definitive, but much less exciting [API documentation](https://petereon.github.io/beaupy/api/)

  From PyPI:
  ```sh
  pip install beaupy
  ```
  From [Conda](https://github.com/conda-forge/beaupy-feedstock) (kindly set up and maintained by [@thewchan](https://github.com/thewchan)):
  ```sh
  conda config --add channels conda-forge
  conda config --set channel_priority strict
  conda install beaupy
  ```
  From source:
  ```sh
  git clone https://github.com/petereon/beaupy.git
  poetry build
  pip install ./dist/beaupy-{{some-version}}-py3-none-any.whl
  ```

  This repository has a [associated GitHub project](https://github.com/users/petereon/projects/3/views/1) where work that is currently done can be seen.

  If you would like to contribute, please feel free to suggest features or implement them yourself.
  Also **please report any issues and bugs you might find!**

  To start development you can clone the repository:
  ```sh
  git clone https://github.com/petereon/beaupy.git
  ```
  Change the directory to the project directory:
  ```sh
  cd ./beaupy/
  ```
  This project uses [`poetry`](https://python-poetry.org/) as a dependency manager. You can install the dependencies using:
  ```sh
  poetry install
  ```
  For testing, this project relies on [`ward`](https://github.com/darrenburns/ward). It is included as a development dependency, so
  after installing the dependencies you can simply execute the following:
  ```sh
  poetry run poe test
  ```
  Making sure the code follows quality standards and formatting can be ensured by executing
  ```sh
  poetry run poe lint
  ```
  You can also have the tests and lints run after every saved change by executing a respective watch command
  ```sh
  poetry run poe test:watch
  ```
  or
  ```sh
  poetry run poe lint:watch
  ```
  After you have made your changes, create a pull request towards a master branch of this repository
  Looking forward to your pull requests!

  Internal logic of `beaupy` is supported for all the major platforms (Windows, Linux, macOS).
  - For user input from console, `beaupy` relies on [petereon/yakh](https://github.com/petereon/yakh), which is tested against all the major platforms and Python versions.
  - For printing to console `beaupy` relies on [Textualize/rich](https://github.com/Textualize/rich), which [supports](https://github.com/Textualize/rich#compatibility) all the major platforms.

  - From version `0.1.7` the CLI elements cause issue with displaying `pdb` prompt ([#93](https://github.com/petereon/beaupy/issues/93)).
  - From version `2.0.0` arrow keys reportedly don't always work on Windows. Resolved in `3.0.0`.
  - From version `3.5.0` there were various option display bugs in `select` and `select_multiple`. Resolved in `3.5.4`.
  - From version `3.9.0`, the CLI elements default to persisting in the terminal after they finish executing. Resolved in `3.9.2`.

  - [therealOri/Genter](https://github.com/therealOri/Genter): A strong password generator and built in password manager made with python3!
  - [therealOri/byte](https://github.com/therealOri/byte): Steganography Image/Data Injector. For artists or people to inject their own Datamark "Watermark" into their images/art or files!
  - [AnirudhG07/ntfyme](https://github.com/AnirudhG07/ntfyme): A notification tool to notify you about status of your long running processes on termination via local-notification, Gmail, Telergram, etc.

  The project is licensed under the [MIT License](https://raw.githubusercontent.com/petereon/beaupy/master/LICENSE).


pkgId: 6ba7ad9335bd58420e420d52b3acfda6de4c0c7bd03725d11d351437ee4031f1
name: python-bedrock-tools-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for bedrock-tools
url: https://github.com/jritsema/bedrock-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bedrock-tools-0.2.1-1.src.rpm
location_href: Packages/python-bedrock-tools-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  A small Python library that simplifies [Amazon Bedrock Converse API function calling](https://docs.aws.amazon.com/bedrock/latest/userguide/tool-use.html) (i.e., tool use).

  This library reduces the boilerplate code needed to integrate native Python functions with the Amazon Bedrock Converse API, making it easier to create powerful, tool-augmented conversational AI applications.




  ```sh
  pip install bedrock-tools
  ```

  ```python
  from bedrock_tools import BedrockTools



  def add_numbers(a: int, b: int) -> int:
      """Add two numbers together."""
      return a + b


  def greet(name: str) -> str:
      """Greet a person by name."""
      return f"Hello, {name}!"


  def get_weather(city: str, state: str) -> dict:
      """Get the weather for a location."""
      return {
          "city": city,
          "state": state,
          "temperature": "75°F",
          "condition": "Partly Cloudy",
      }


  tools = BedrockTools()
  tools.add_function(add_numbers)
  tools.add_function(greet)
  tools.add_function(get_weather)


  response = bedrock.converse(
      modelId=model_id,
      toolConfig=tools.get_tool_config()
      messages=messages,
  )


  if "toolUse" in content_block:
      tool_results.append(tools.invoke(content_block["toolUse"]))

  message = {"role": "user", "content": tool_results}
  ```


  Here's an example (from the [Bedrock Converse API docs](https://docs.aws.amazon.com/bedrock/latest/userguide/tool-use-examples.html)) with and without the library:

  ![alt text](img/image.png)

  ![alt text](img/image-2.png)




  Currently supports function parameters of type:

  - scalar
      - str -> string
      - int -> integegr
      - bool -> boolean
      - float -> number
  - list
      - str -> string
      - int -> integer
      - bool -> boolean
      - float -> number
  - dict -> object




  ```
   Choose a make command to run

    init      run this once to initialize a new python project
    install   install project dependencies
    start     run local project
    test      run unit tests
  ```


pkgId: 6ef22b46f3967c6482da10453b1bed85f299c22b4e0830167cd4ea72c2d7d6f8
name: python-beetcamp-help
arch: noarch
version: 0.21.0
epoch: 0
release: 1
summary: Development documents and examples for beetcamp
url: https://github.com/snejus/beetcamp
rpm_license: GPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beetcamp-0.21.0-1.src.rpm
location_href: Packages/python-beetcamp-help-0.21.0-1.noarch.rpm
checksum_type: sha256
description:
  [![image](http://img.shields.io/pypi/v/beetcamp.svg)](https://pypi.python.org/pypi/beetcamp)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=snejus_beetcamp&metric=alert_status)](https://sonarcloud.io/dashboard?id=snejus_beetcamp)
  [![Coverage Status](https://coveralls.io/repos/github/snejus/beetcamp/badge.svg?branch=main)](https://coveralls.io/github/snejus/beetcamp?branch=main)
  [ ![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Fsnejus%2Fbeetcamp&count_bg=%23842424&title_bg=%23846060&icon=postwoman.svg&icon_color=%23CF4D4D&title=hits&edge_flat=true)](https://hits.seeyoufarm.com)
  Bandcamp autotagger plugin for [beets]. It mostly focuses on
  - Staying up-to-date with information Bandcamp provide in the JSON metadata
  - Parsing **all possible** (if relevant) metadata from various places
    - For example, a catalog number given in the release or media description
  - Correctness of the data
    - For example, determining artist names from various artists releases
  - Compliance with MusicBrainz fields format, to remove the need for pre-processing if, for
    example, one wishes to upload the metadata to MB.
  Thanks to [unrblt] for [beets-bandcamp] providing the idea and initial implementation.
  [beets]: https://github.com/beetbox/beets
  [unrblt]: https://github.com/unrblt
  [beets-bandcamp]: https://github.com/unrblt/beets-bandcamp


  1. Install `beets` with `pipx` so that it's isolated from your system and other projects
  ```bash
  pipx install beets
  ```
  2. Inject `beetcamp` and other dependencies that you need. The `--include-apps` flag is required to make sure that `beetcamp` is made available in your command line.
  ```bash
  pipx inject --include-apps beets beetcamp [python-mpd2 ...]
  ```
  3. Add `bandcamp` to the `plugins` list to your beets configuration file.

  Navigate to your `beets` virtual environment and install the plug-in with
  ```bash
  pip install beetcamp
  ```

  The plugin exposes some of its functionality through a command-line application `beetcamp`:
  ```xml
  usage: beetcamp [-h] [-a] [-l] [-t] [-o INDEX] [-p PAGE] (release_url | query)
  Get bandcamp release metadata from the given <release-url> or perform
  bandcamp search with <query>. Anything that does not start with https://
  will be assumed to be a query. Search type flags: -a for albums, -l for
  labels and artists, -t for tracks. By default, all types are searched.
  positional arguments:
    release_url  Release URL, starting with https:// OR
    query        Search query
  optional arguments:
    -h, --help   show this help message and exit
    -a, --album  Search albums
    -l, --label  Search labels and artists
    -t, --track  Search tracks
    -o INDEX, --open INDEX
                          Open search result indexed by INDEX in the browser
    -p PAGE, --page PAGE  The results page to show, 1 by default
  ```
  - Use `beetcamp <bandcamp-release-url>` to return release metadata in JSON format.
  - Use `beetcamp [-alt] <query>` to search albums, labels and tracks on Bandcamp and return
    results in JSON.
  - Search results are indexed - add `-o <index>` in order to open the chosen URL in the browser.
  You can see how the data looks below (the output is prettified with [rich-tables]).
  ![image](https://github.com/snejus/beetcamp/blob/fe6ea71a0ab0035d657d13f664de957befb4552c/images/search.png?raw=true)
  [rich-tables]: https://github.com/snejus/rich-tables


  ```yaml
  bandcamp:
    include_digital_only_tracks: true
    search_max: 2
    art: yes
    comments_separator: "\n---\n"
    truncate_comments: no
    exclude_extra_fields: []
    genre:
      capitalize: no
      maximum: 0
      always_include: []
      mode: progressive # classical, progressive or psychedelic


pkgId: 39d0e2bf5d5a22f3b02ea2289db921200ad6044c0665a0c74b295c92553d1e7c
name: python-beetl-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for beetl
url: https://pypi.org/project/beetl/
rpm_license: GnuPG 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beetl-1.0.2-1.src.rpm
location_href: Packages/python-beetl-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  <h1 style="width: 100%; text-align: center; margin-bottom: 20px; border-bottom: 0px;">BeETL: Extensible Python/Polars-based ETL Framework</h1>
  <p style="text-align: center; margin-bottom: 30px;"><img src="./docs/images/beetl.jpg" style="max-width: 400px;" alt=" "><br/></p>
  BeETL was born from a job as Integration Developer where a majority of the integrations we develop follow the same pattern - get here, transform a little, put there (with the middle step frequently missing altogether).

  After building our 16th integration between the same two systems with another manual template, we decided to build BeETL. BeETL is currently limited to one datasource per source and destination per sync, but this will be expanded in the future. One configuration can contain multiple syncs.

  Note: Even though some of the configuration below is in YAML format, you can also use JSON or a python dictionary.


  - [Minimal example](#minimal-example)
  - [Installation](#installation)
    - [From PyPi](#from-pypi)
    - [From Source](#from-source)
  - [Getting Started](#getting-started)
  - [Development Environment](#development-environment)
  - [Documentation](https://beetl.docs.hoglan.dev/)
  - [Source Code](https://github.com/hoglandets-it/beetl)



  ```python

  from src.beetl.beetl import Beetl, BeetlConfig
  config = BeetlConfig({
      "version": "V1"
      "sources": [
          {
              "name": "Sqlserver",
              "type": "Sqlserver",
              "connection": {
                  "settings": {
                      "connection_string": "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;"
                  }
              }
          },
      "sync": [
          {
              "name": "Sync between two tables in a sql server",
              "source": "Sqlserver",
              "sourceConfig": {
                  "query": "SELECT id, name, email FROM users"
              }
              "destination": "SqlServer",
              "destinationConfig": {
                  "table": "users",
                  "unique_columns": ["id"]
              }
              "comparisonColumns": [
                  {
                      "name": "id",
                      "type": "Int32",
                      "unique": True
                  },
                  {
                      "name": "name",
                      "type": "Utf8"
                  },
                  {
                      "name": "email",
                      "type": "Utf8"
                  }
              ]
          }
      ]
  })

  Beetl(config).sync()

  ```



  ```bash

  python -m pip install beetl
  ```


  ```bash


  git clone https://github.com/Hoglandets-IT/beetl.git
  cd ./beetl

  python -m pip install build

  python -m build

  python -m pip install ./dist/*.tar.gz
  ```



  All the latest information about how to use beetl is located at the [official docs](https://beetl.docs.hoglan.dev/getting-started.html).




  The easiest way to get started is to use the included devcontainer.


  - Docker
  - Visual Studio Code



  1. Clone the repository.
  1. Open the repository in Visual Studio Code.
  1. Install the recommended extensions.
  1. Using the command palette (`ctrl+shift+p`) search for `reopen in container` and run it.
     - The devcontainer will now be provisioned in your local docker instance and vscode will automatically connect to it.
  1. You can now use the included launch profiles to either open the docs or run the tests file.
  1. You can also use the built-in test explorer to run the available test.


pkgId: d980a41f0e11ded7d0867c93de867caa7d929fb5caecce826a651ab60f431526
name: python-beets-audible-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for beets-audible
url: https://github.com/Neurrone/beets-audible
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beets-audible-1.0.1-1.src.rpm
location_href: Packages/python-beets-audible-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
     version: "3"
     services:
       beets:
         image: lscr.io/linuxserver/beets:2.0.0
         container_name: beets
         environment:
           
           - PUID=1000
           - PGID=1000
           - TZ=Asia/Singapore
         volumes:
           - ./config:/config
           - ./scripts:/custom-cont-init.d
           - /path/to/audiobooks:/audiobooks
           - /path/to/import/books/from:/input
         restart: unless-stopped
     ```
  3. Save the following under `scripts/install-deps.sh`:
     ```sh
     
     echo "Installing dependencies..."
     
     pip install --no-cache-dir beets-audible beets-copyartifacts3
     ```
  4. Spin up the container: `docker-compose up -d`
  5. Update the config in `config/config.yaml` as described above.
  6. In the docker container, run the `beet --version` command and verify that the audible plugin appears in the list of plugins.

  When importing audiobooks into Beets, ensure that the files for each book are in its own folder, even if the audiobook only consists of a single file. This is so that the files for a book are treated as an album by Beets. Avoid putting files from multiple books in the same folder.
  When ready, start the import by executing the following command in the container:
  ```sh
  beet import /path/to/audiobooks
  ```
  The following sources of information are used to search for book matches in order of preference:
  1. A file containing book info named `metadata.yml` (see below)
  2. Album and artist tags
  3. If tags are missing from the file, enabling the fromfilename plugin will attempt to deduce album and artist from file names
  4. If all else fails, use the folder name as the query string
  If you're not getting a match for a book, try the following:
  1. Check the tags on the files being imported. The album and artist tags should be set to the book title and author respectively.
  2. Press `E` when Beets prompts you about not being able to find a match. This prompts for the artist and album name. If the wrong book is being matched because there are other books with similar names on Audible, try using the audiobook's asin as the artist and title as the album.
  3. Switch Audible service region to obtain metadata from:
      * Set `region` in the beets config.
      * Press `R` to set region for a book when Beets prompts you about not being able to find a match or if it is incorrect.
  4. Specify the book's data by using `metadata.yml` if it isn't on Audible (see the next section).
  The plugin gets chapter data of each book and tries to match them to the imported files if and only if the number of imported files is the same as the number of chapters from Audible. This can fail and cause inaccurate track assignments if the lengths of the files don't match Audible's chapter data. If this happens, set the config option `match_chapters` to `false` temporarily and try again, and remember to uncomment that line once done.

  The plugin can search Goodreads to find the original publication date of the work the audiobook is based on by searching on the ASIN. To enable this option you need a Goodreads API key and you must set that key in the audible plugin config
  ```
     audible:
       goodreads_apikey: [APIKEYHERE] #optional
  ```
  If you want this date used as the release date for the audiobook, you must set [original_date](https://beets.readthedocs.io/en/stable/reference/config.html#original-date) to yes in your beets config

  The plugin looks for a file called `metadata.yml` in each book's folder during import. If this file is present, it exclusively uses the info in it for tagging and skips the Audible lookup.
  This is meant for importing audio content that isn't on Audible.
  Here's an example of what `metadata.yml` should look like:


pkgId: 411f451924109318dedc9f2b6c529f12951218598208928208bef25e4dc08556
name: python-bellande-particle-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for bellande-particle
url: https://github.com/Robotics-Sensors/bellande_particle
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bellande-particle-0.0.1-1.src.rpm
location_href: Packages/python-bellande-particle-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  - [![Organization Website](https://img.shields.io/badge/Explore%20Our-Website-0099cc?style=for-the-badge)](https://robotics-sensors.github.io)


  - [![Organization Github ](https://img.shields.io/badge/Explore%20Our-Github-0099cc?style=for-the-badge)](https://github.com/Robotics-Sensors)


  - **Ronaldson Bellande**


  ```















  url: https://bellande-robotics-sensors-research-innovation-center.org

  endpoint_path:
      bellande_particle: /api/Bellande_Particle/bellande_particle

  Bellande_Framework_Access_Key: bellande_web_api_opensource
  ```


  ```
  {
    "license": [
      "Copyright (C) 2024 Bellande Robotics Sensors Research Innovation Center, Ronaldson Bellande",
      "This program is free software: you can redistribute it and/or modify",
      "it under the terms of the GNU General Public License as published by",
      "the Free Software Foundation, either version 3 of the License, or",
      "(at your option) any later version.",
      "",
      "This program is distributed in the hope that it will be useful,",
      "but WITHOUT ANY WARRANTY; without even the implied warranty of",
      "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the",
      "GNU General Public License for more details.",
      "",
      "You should have received a copy of the GNU General Public License",
      "along with this program.  If not, see <https://www.gnu.org/licenses/>.",
      "GNU General Public License v3.0 or later"
    ],
    "url": "https://bellande-robotics-sensors-research-innovation-center.org",
    "endpoint_path": {
      "bellande_particle": "/api/Bellande_Particle/bellande_particle"
    },
    "Bellande_Framework_Access_Key": "bellande_web_api_opensource"
  }
  ```


  ```
  {
      "particle": [0, 0, 0, 1.0],
      "movement": {
          "rotation1": 45.0,
          "translation": 1.0,
          "rotation2": -45.0
      },
      "world": {
          "width": 10.0,
          "height": 10.0,
          "markers": [[1.0, 1.0]]
      },
      "count": 10,
      "auth": {
          "authorization_key": "bellande_web_api_opensource"
      }
  }
  ```


  - [![Website API Testing](https://img.shields.io/badge/Bellande%20API-Testing-0099cc?style=for-the-badge)](https://bellande-robotics-sensors-research-innovation-center.org/api/bellande_particles_experiment)


  ```
  curl -X 'POST' \
    'https://bellande-robotics-sensors-research-innovation-center.org/api/Bellande_Particle/bellande_particle' \
    -H 'accept: application/json' \
    -H 'Content-Type: application/json' \
    -d '{
      "particle": [0, 0, 0, 1.0],
      "movement": {
          "rotation1": 45.0,
          "translation": 1.0,
          "rotation2": -45.0
      },
      "world": {
          "width": 10.0,
          "height": 10.0,
          "markers": [[1.0, 1.0]]
      },
      "count": 10,
      "auth": {
          "authorization_key": "bellande_web_api_opensource"
      }
    }'
  ```




  - https://crates.io/crates/bellande_particle


  - `cargo add bellande_particle`


  - https://pypi.org/project/bellande_particle


  - `$ pip install bellande_particle`


  ```
  bellande_particle \
    --particle "[0, 0, 0, 1.0]" \
    --movement '{"rotation1": 45.0, "translation": 1.0, "rotation2": -45.0}' \
    --world '{"width": 10.0, "height": 10.0, "markers": [[1.0, 1.0]]}' \
    --count 10
  ```


  - `$ pip install --upgrade bellande_particle`

  ```
  Name: bellande_particle
  Summary: A particle system using Bellande distributions for robust state estimation and localization
  Home-page: github.com/Robotics-Sensors/bellande_particle
  Author: Ronaldson Bellande
  Author-email: ronaldsonbellande@gmail.com
  License: GNU General Public License v3.0
  ```


  This Algorithm or Models is distributed under the [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/), see [LICENSE](https://github.com/Robotics-Sensors/bellande_particle/blob/main/LICENSE) and [NOTICE](https://github.com/Robotics-Sensors/bellande_particle/blob/main/LICENSE) for more information.


pkgId: 60a69befaa600300aec5c4418cfcc58e115535492a274e3ac3d571051cba82c4
name: python-belogging-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for belogging
description: *Don't fight with logging ...*
url: https://pypi.org/project/belogging/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-belogging-0.2.0-1.src.rpm
location_href: Packages/python-belogging-help-0.2.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2016 George Kussumoto  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: 830f2ac44954da21fb64e01c4f93a8894d1026aa032e8234841e1216d8f3e367
name: python-bemi-django-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for bemi-django
url: https://github.com/BemiHQ/bemi-django
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bemi-django-0.1.3-1.src.rpm
location_href: Packages/python-bemi-django-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
   26          | todo  | CREATE    | {}                                                 | {"id": 26, "task": "Sleep", "is_completed": false}  | {"user_id": 187234, "endpoint": "/todo", "method": "POST", "SQL": "INSERT INTO ..."}      | 2023-12-11 17:09:09+00
   27          | todo  | CREATE    | {}                                                 | {"id": 27, "task": "Eat", "is_completed": false}    | {"user_id": 187234, "endpoint": "/todo", "method": "POST", "SQL": "INSERT INTO ..."}      | 2023-12-11 17:09:11+00
   28          | todo  | CREATE    | {}                                                 | {"id": 28, "task": "Repeat", "is_completed": false} | {"user_id": 187234, "endpoint": "/todo", "method": "POST", "SQL": "INSERT INTO ..."}      | 2023-12-11 17:09:13+00
   26          | todo  | UPDATE    | {"id": 26, "task": "Sleep", "is_completed": false} | {"id": 26, "task": "Sleep", "is_completed": true}   | {"user_id": 187234, "endpoint": "/todo/complete", "method": "PUT", "SQL": "UPDATE ..."}   | 2023-12-11 17:09:15+00
   27          | todo  | DELETE    | {"id": 27, "task": "Eat", "is_completed": false}   | {}                                                  | {"user_id": 187234, "endpoint": "/todo/27", "method": "DELETE", "SQL": "DELETE FROM ..."} | 2023-12-11 17:09:18+00
  ```
  Check out our [Django docs](https://docs.bemi.io/orms/django) for more details.

  Bemi is designed to be lightweight and secure. It takes a practical approach to achieving the benefits of [event sourcing](https://blog.bemi.io/rethinking-event-sourcing/) without requiring rearchitecting existing code, switching to highly specialized databases, or using unnecessary git-like abstractions on top of databases. We want your system to work the way it already does with your existing database to allow keeping things as simple as possible.
  Bemi plugs into both the database and application levels, ensuring 100% reliability and a comprehensive understanding of every change.
  On the database level, Bemi securely connects to PostgreSQL's [Write-Ahead Log](https://www.postgresql.org/docs/current/wal-intro.html) and implements [Change Data Capture](https://blog.bemi.io/cdc/). This allows tracking even the changes that get triggered via direct SQL.
  On the application level, this Python package automatically passes application context to the replication logs to enhance the low-level database changes. For example, information about a user who made a change, an API endpoint where the change was triggered, a worker name that automatically triggered database changes, etc.
  Bemi workers then stitch the low-level data with the application context and store this information in a structured easily queryable format, as depicted below:
  ![bemi-architechture](https://docs.bemi.io/img/architecture.png)
  The cloud solution includes worker ingesters, queues for fault tolerance, and a serverless PostgreSQL. If you are interested in running a self-hosted version yourself, see our [self-hosting docs](https://docs.bemi.io/self-hosting).

  Distributed under the terms of the [LGPL-3.0 License](LICENSE).
  If you need to modify and distribute the code, please release it to contribute back to the open-source community.


pkgId: b43a19fe082b9bcc66dd13374021fc2fad75a7c51934b6a8dad0c9f68391f671
name: python-benchling-api-client-help
arch: noarch
version: 2.0.346
epoch: 0
release: 1
summary: Development documents and examples for benchling-api-client
url: https://pypi.org/project/benchling-api-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-benchling-api-client-2.0.346-1.src.rpm
location_href: Packages/python-benchling-api-client-help-2.0.346-1.noarch.rpm
checksum_type: sha256
description:
  A client generated from Benchling's OpenAPI definition files using openapi-python-client.

  Rather than using this package directly, we recommend using the
  [Benchling SDK](https://pypi.org/project/benchling-sdk/), which has extra scaffolding to make some endpoints
  easier to use and has been released to general availability.


pkgId: 92e3ed124e57f12d409564cc4048e2a3aa9379bafb9fe2526f2f69cd40143183
name: python-benchmark-runner-help
arch: noarch
version: 1.0.707
epoch: 0
release: 1
summary: Development documents and examples for benchmark-runner
url: https://github.com/redhat-performance/benchmark-runner
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-benchmark-runner-1.0.707-1.src.rpm
location_href: Packages/python-benchmark-runner-help-1.0.707-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/redhat-performance/benchmark-runner/actions/workflows/Perf_Env_Build_Test_CI.yml/badge.svg)](https://github.com/redhat-performance/benchmark-runner/actions)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/benchmark-runner.svg)](https://pypi.org/project/benchmark-runner/)
  [![Container Repository on Quay](https://quay.io/repository/projectquay/quay/status "Container Repository on Quay")](https://quay.io/repository/benchmark-runner/benchmark-runner?tab=tags)
  [![Coverage Status](https://coveralls.io/repos/github/redhat-performance/benchmark-runner/badge.svg?branch=main)](https://coveralls.io/github/redhat-performance/benchmark-runner?branch=main&kill_cache=1)
  [![Documentation Status](https://readthedocs.org/projects/benchmark-runner/badge/?version=latest)](https://benchmark-runner.readthedocs.io/en/latest/?badge=latest)
  [![python](https://img.shields.io/pypi/pyversions/benchmark-runner.svg?color=%2334D058)](https://pypi.org/project/benchmark-runner)
  [![License](https://img.shields.io/pypi/l/benchmark-runner.svg)](https://github.com/redhat-performance/benchmark-runner/blob/main/LICENSE)

  **benchmark-runner** is a containerized Python lightweight and flexible framework for running benchmark workloads
  on Kubernetes/OpenShift runtype kinds Pod, kata and VM.
  This framework support the following embedded workloads:
  * [hammerdb](https://hammerdb.com/): running hammerdb workload on the following databases: MSSQL, Mariadb, Postgresql in Pod, Kata or VM with [Configuration](benchmark_runner/common/template_operations/templates/hammerdb)
  * [stressng](https://wiki.ubuntu.com/Kernel/Reference/stress-ng): running stressng workload in Pod, Kata or VM [Configuration](benchmark_runner/common/template_operations/templates/stressng)
  * [uperf](http://uperf.org/): running uperf workload in Pod, Kata or VM with [Configuration](benchmark_runner/common/template_operations/templates/uperf)
  * [vdbench](https://wiki.lustre.org/VDBench/): running vdbench workload in Pod, Kata or VM with [Configuration](benchmark_runner/common/template_operations/templates/vdbench)
  * [bootstorm](https://en.wiktionary.org/wiki/boot_storm): calculate VMs boot load time [Configuration](benchmark_runner/common/template_operations/templates/bootstorm)
  ** For hammerdb mssql must run once [permission](https://github.com/redhat-performance/benchmark-runner/blob/main/benchmark_runner/common/ocp_resources/custom/template/02_mssql_patch_template.sh)
  Benchmark-runner grafana dashboard example:
  ![](media/grafana.png)
  Reference:
  * The benchmark-runner package is located in [PyPi](https://pypi.org/project/benchmark-runner)
  * The benchmark-runner container image is located in [Quay.io](https://quay.io/repository/benchmark-runner/benchmark-runner)

  Documentation is available at [benchmark-runner.readthedocs.io](https://benchmark-runner.readthedocs.io/en/latest/)
  ![](media/docker2.png)
  _**Table of Contents**_
  <!-- TOC -->
  - [Benchmark-Runner](#benchmark-runner)
    - [Documentation](#documentation)
    - [Run workload using Podman or Docker](#run-workload-using-podman-or-docker)
    - [Run workload in Pod using Kubernetes or OpenShift](#run-workload-in-pod-using-kubernetes-or-openshift)
    - [Grafana dashboards](#grafana-dashboards)
    - [Inspect Prometheus Metrics](#inspect-prometheus-metrics)
    - [How to develop in benchmark-runner](#how-to-develop-in-benchmark-runner)
  <!-- /TOC -->

  The following options may be passed via command line flags or set in the environment:
  **mandatory:** KUBEADMIN_PASSWORD=$KUBEADMIN_PASSWORD
  **mandatory:** $KUBECONFIG [ kubeconfig file path]
  **mandatory:** WORKLOAD=$WORKLOAD
  Choose one from the following list:
  `['stressng_pod', 'stressng_vm', 'stressng_kata', 'uperf_pod', 'uperf_vm', 'uperf_kata', 'hammerdb_pod_mariadb', 'hammerdb_vm_mariadb', 'hammerdb_kata_mariadb', 'hammerdb_pod_mariadb_lso', 'hammerdb_vm_mariadb_lso', 'hammerdb_kata_mariadb_lso', 'hammerdb_pod_postgres', 'hammerdb_vm_postgres', 'hammerdb_kata_postgres', 'hammerdb_pod_postgres_lso', 'hammerdb_vm_postgres_lso', 'hammerdb_kata_postgres_lso', 'hammerdb_pod_mssql', 'hammerdb_vm_mssql', 'hammerdb_kata_mssql', 'hammerdb_pod_mssql_lso', 'hammerdb_vm_mssql_lso', 'hammerdb_kata_mssql_lso', 'vdbench_pod', 'vdbench_kata', 'vdbench_vm', 'clusterbuster', 'bootstorm_vm']`
  ** clusterbuster workloads: cpusoaker, files, fio, uperf. for more details [see](https://github.com/RobertKrawitz/OpenShift4-tools)
  Not mandatory:
  **auto:** NAMESPACE=benchmark-operator [ The default namespace is benchmark-operator ]
  **auto:** ODF_PVC=True [ True=ODF PVC storage, False=Ephemeral storage, default True ]
  **auto:** EXTRACT_PROMETHEUS_SNAPSHOT=True [ True=extract Prometheus snapshot into artifacts, false=don't, default True ]
  **auto:** SYSTEM_METRICS=False [ True=collect metric, False=not collect metrics, default False ]
  **auto:** RUNNER_PATH=/tmp [ The default work space is /tmp ]
  **optional:** PIN_NODE_BENCHMARK_OPERATOR=$PIN_NODE_BENCHMARK_OPERATOR [node selector for benchmark operator pod]
  **optional:** PIN_NODE1=$PIN_NODE1 [node1 selector for running the workload]
  **optional:** PIN_NODE2=$PIN_NODE2 [node2 selector for running the workload, i.e. uperf server and client, hammerdb database and workload]
  **optional:** ELASTICSEARCH=$ELASTICSEARCH [ elasticsearch service name]
  **optional:** ELASTICSEARCH_PORT=$ELASTICSEARCH_PORT
  **optional:** CLUSTER=$CLUSTER [ set CLUSTER='kubernetes' to run workload on a kubernetes cluster, default 'openshift' ]
  **optional:scale** SCALE=$SCALE [For Vdbench/Bootstorm: Scale in each node]
  **optional:scale** SCALE_NODES=$SCALE_NODES [For Vdbench/Bootstorm: Scale's node]
  **optional:scale** REDIS=$REDIS [For Vdbench only: redis for scale synchronization]
  **optional:** LSO_DISK_ID=$LSO_DISK_ID [LSO_DISK_ID='scsi-<replace_this_with_your_actual_disk_id>' For using LSO Operator in hammerdb]
  **optional:** WORKER_DISK_IDS=$WORKER_DISK_IDS [WORKER_DISK_IDS For ODF/LSO workloads hammerdb/vdbench]
  For example:
  ```sh
  podman run --rm -e WORKLOAD="hammerdb_pod_mariadb" -e KUBEADMIN_PASSWORD="1234" -e PIN_NODE_BENCHMARK_OPERATOR="node_name-0" -e PIN_NODE1="node_name-1" -e PIN_NODE2="node_name-2" -e log_level=INFO -v /root/.kube/config:/root/.kube/config --privileged quay.io/benchmark-runner/benchmark-runner:latest
  ```
  or
  ```sh
  docker run --rm -e WORKLOAD="hammerdb_vm_mariadb" -e KUBEADMIN_PASSWORD="1234" -e PIN_NODE_BENCHMARK_OPERATOR="node_name-0" -e PIN_NODE1="node_name-1" -e PIN_NODE2="node_name-2" -e log_level=INFO -v /root/.kube/config:/root/.kube/config --privileged quay.io/benchmark-runner/benchmark-runner:latest
  ```
  SAVE RUN ARTIFACTS LOCAL:
  1. add `-e SAVE_ARTIFACTS_LOCAL='True'` or `--save-artifacts-local=true`
  2. add `-v /tmp:/tmp`
  3. git clone -b v1.0.3 https://github.com/cloud-bulldozer/benchmark-operator /tmp/benchmark-operator

  ![](media/benchmark-runner-demo.gif)

  ![](media/benchmark-runner-k8s-demo.gif)

  [TBD]

  There are 2 grafana dashboards templates:
  1. [FuncCi dashboard](benchmark_runner/grafana/func/dashboard.json)
  2. [PerfCi dashboard](benchmark_runner/grafana/perf/dashboard.json)
  ** PerfCi dashboard is generated automatically in [Build GitHub actions](https://github.com/redhat-performance/benchmark-runner/blob/main/.github/workflows/Perf_Env_Build_Test_CI.yml) from [main.libsonnet](benchmark_runner/grafana/perf/jsonnet/main.libsonnet)
  ** After importing json in grafana, you need to configure elasticsearch data source. (for more details: see [HOW_TO.md](HOW_TO.md))

  The CI jobs store snapshots of the Prometheus database for each run as part of the artifacts.  Within the artifact directory is a Prometheus snapshot directory named:
  ```
  promdb-YYYY_MM_DDTHH_mm_ss+0000_YYYY_MM_DDTHH_mm_ss+0000.tar
  ```
  The timestamps are for the start and end of the metrics capture; they
  are stored in UTC time (`+0000`).  It is possible to run containerized
  Prometheus on it to inspect the metrics.  *Note that Prometheus
  requires write access to its database, so it will actually write to
  the snapshot.* So for example if you have downloaded artifacts for a
  run named `hammerdb-vm-mariadb-2022-01-04-08-21-23` and the Prometheus
  snapshot within is named
  `promdb_2022_01_04T08_21_52+0000_2022_01_04T08_45_47+0000`, you could run as follows:
  ```
  $ local_prometheus_snapshot=/hammerdb-vm-mariadb-2022-01-04-08-21-23/promdb_2022_01_04T08_21_52+0000_2022_01_04T08_45_47+0000
  $ chmod -R g-s,a+rw "$local_prometheus_snapshot"
  $ sudo podman run --rm -p 9090:9090 -uroot -v "$local_prometheus_snapshot:/prometheus" --privileged prom/prometheus --config.file=/etc/prometheus/prometheus.yml --storage.tsdb.path=/prometheus --storage.tsdb.retention.time=100000d --storage.tsdb.retention.size=1000PB
  ```
  and point your browser at port 9090 on your local system, you can run queries against it, e.g.
  ```
  sum(irate(node_cpu_seconds_total[2m])) by (mode,instance) > 0
  ```
  It is important to use the `--storage.tsdb.retention.time` option to
  Prometheus, as otherwise Prometheus may discard the data in the
  snapshot.  And note that you must set the time bounds on the
  Prometheus query to fit the start and end times as recorded in the
  name of the promdb snapshot.

  see [HOW_TO.md](HOW_TO.md)


pkgId: 689200297d9c68b4e2fe3bc084673f34a098c78b2fe69c4f0feef86f67944633
name: python-bento-tools-help
arch: noarch
version: 2.1.4
epoch: 0
release: 1
summary: Development documents and examples for bento-tools
url: https://pypi.org/project/bento-tools/
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bento-tools-2.1.4-1.src.rpm
location_href: Packages/python-bento-tools-help-2.1.4-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/github/license/ckmah/bento-tools.svg)](https://github.com/ckmah/bento-tools/blob/master/LICENSE)


pkgId: f36df0ec2d61b077775fa9a472a6be03fa2551525292658cdd25a418c08658ae
name: python-beschi-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for beschi
url: https://github.com/sjml/beschi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beschi-0.3.1-1.src.rpm
location_href: Packages/python-beschi-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- Note to future self: using absolute links to documentation here so they work properly on the PyPI page. -->


  [![PyPI](https://img.shields.io/pypi/v/beschi)](https://pypi.org/project/beschi/) [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/sjml/beschi/ci.yml)](https://github.com/sjml/beschi/actions/workflows/ci.yml)

  This is a custom bit-packing and unpacking code generator for C, C#, Go, Rust, Swift, TypeScript, AssemblyScript, and Zig. You feed it a data description and it generates source files for writing/reading buffers of that data, along the lines of [FlatBuffers](https://google.github.io/flatbuffers/) or [Cap'n Proto](https://capnproto.org), but with much less functionality for much simpler use cases. It was initially written for a larger project that was passing data back and forth between a Unity game, a Go server, and a web client, but I extracted it into its own thing. If all you need is a simple way to pack a data structure into a compact, portable binary form, this might be useful for you.

  I go into more explanation for why this exists [in the documentation](https://github.com/sjml/beschi/tree/main/docs/), but I'll be honest, too: it **was** kind of fun to write a code generator. 😝



  * [Introduction](https://github.com/sjml/beschi/tree/main/docs/introduction.md)
  * [Protocols](https://github.com/sjml/beschi/tree/main/docs/protocols.md)

  Language-Specific Documentation:

  | [C](https://github.com/sjml/beschi/tree/main/docs/languages/c.md) | [C#](https://github.com/sjml/beschi/tree/main/docs/languages/csharp.md) | [Go](https://github.com/sjml/beschi/tree/main/docs/languages/go.md) | [Rust](https://github.com/sjml/beschi/tree/main/docs/languages/rust.md) | [Swift](https://github.com/sjml/beschi/tree/main/docs/languages/swift.md) | [TypeScript](https://github.com/sjml/beschi/tree/main/docs/languages/typescript.md) | [AssemblyScript](https://github.com/sjml/beschi/tree/main/docs/languages/assemblyscript.md) | [Zig](https://github.com/sjml/beschi/tree/main/docs/languages/zig.md)
  |-|-|-|-|-|-|-|-|

  * [Dev Notes](https://github.com/sjml/beschi/tree/main/docs/dev)




  If you use [Homebrew](https://brew.sh), you can install it directly and simply:

  ```
  brew install sjml/sjml/beschi
  ```

  Otherwise, you need a Python setup and can then install from [PyPI](https://pypi.org/project/beschi/):

  ```
  pip install beschi
  ```

  It installs an executable that you can run directly, so long as however you invoked `pip` put it on your path. (This will work in an activated virtual environment, for instance.)

  Example:
  ```
  beschi --lang csharp --protocol ./messages.toml
  ```



  By default, it prints to standard output, but you can also write to a file with an output flag like `--output ./Messages.cs`.

  From the input protocol file (detailed below), you get a code file that you can integrate to a project allowing you encode messages as compact and portable binary buffers.




  The protocol files are written in [TOML](https://toml.io). There's [a fuller example in the test suite](https://github.com/sjml/beschi/tree/main/test/_protocols/example.toml) and a [more through explanation in the documentation](https://github.com/sjml/beschi/tree/main/docs/protocols.md), but here's an annotated sample.

  ```toml
  [meta]



  namespace = "AppMessages"





  list_size_type = "uint16"
  string_size_type = "byte"






  [[messages]]
  _name = "Vector3Message"
  x = "float"
  y = "float"
  z = "float"



  [[messages]]
  _name = "NewCharacterMessage"
  id = "uint64"
  characterName = "string"
  job = "CharacterClass" # an enum! (see below)
  strength = "uint16"
  intelligence = "uint16"
  dexterity = "uint16"
  wisdom = "uint16"
  goldInWallet = "uint32"
  nicknames = "[string]" # brackets indicate a list/array




  [[enums]]
  _name = "CharacterClass"
  _values = [
      "Fighter",
      "Wizard",
      "Rogue",
      "Cleric"
  ]



  [[structs]]
  _name = "Color"
  red = "float"
  green = "float"
  blue = "float"
  alpha = "float"


  [[structs]]
  _name = "Spectrum"
  defaultColor = "Color"
  colors = "[Color]"



  [[messages]]
  _name = "CharacterJoinedTeam"
  characterID = "uint64"
  teamName = "string"
  teamColors = "[Color]"
  role = "TeamRole"


  [[enums]]
  _name = "TeamRole"
  _values = [
      
      
      { _name = "Minion",  _value =  256 },
      { _name = "Ally",    _value =  512 },
      { _name = "Leader",  _value = 1024 },
      
      { _name = "Traitor", _value =   -1 }
  ]
  ```

  Note that while [the TOML spec](https://toml.io/en/v1.0.0) does not guarantee the order of table entries, [the Python library which Beschi uses](https://docs.python.org/3/library/tomllib.html) uses order-preserving dictionaries, so if you care about the order of elements in the resulting struct (for memory alignment issues or something), you can re-order them and have that change reflected in the generated code.




  These are the base types from which you can build up whatever structures and messages you need to, along with what they correspond to in the various languages.

  | Protocol Type | C          | C#       | Go        | Rust     | Swift     | TypeScript | AssemblyScript | Zig           |
  |---------------|------------|----------|-----------|----------|-----------|------------|----------------|---------------|
  | **`byte`**    | `uint8_t`  | `byte`   | `byte`    | `u8`     | `UInt8`   | `number`   | `u8`           | `u8`         |
  | **`bool`**    | `bool`     | `bool`   | `bool`    | `bool`   | `Bool`    | `boolean`  | `bool`         | `bool`       |
  | **`int16`**   | `uint16_t` | `short`  | `int16`   | `i16`    | `Int16`   | `number`   | `i16`          | `i16`        |
  | **`uint16`**  | `int16_t`  | `ushort` | `uint16`  | `u16`    | `UInt16`  | `number`   | `u16`          | `u16`        |
  | **`int32`**   | `uint32_t` | `int`    | `int32`   | `i32`    | `Int32`   | `number`   | `i32`          | `i32`        |
  | **`uint32`**  | `int32_t`  | `uint`   | `uint32`  | `u32`    | `UInt32`  | `number`   | `u32`          | `u32`        |
  | **`int64`**   | `uint64_t` | `long`   | `int64`   | `i64`    | `Int64`   | `bigint`   | `i64`          | `i64`        |
  | **`uint64`**  | `int64_t`  | `ulong`  | `uint64`  | `u64`    | `UInt64`  | `bigint`   | `u64`          | `u64`        |
  | **`float`**   | `float`    | `float`  | `float32` | `f32`    | `Float32` | `number`   | `f32`          | `f32`        |
  | **`double`**  | `double`   | `double` | `float64` | `f64`    | `Float64` | `number`   | `f64`          | `f64`        |
  | **`string`**  | `char*`    | `string` | `string`  | `String` | `String`  | `string`   | `string`       | `[]const u8` |

  All the numbers are stored as little-endian in the buffer, if that matters for you.




  Beschi does not generate any code to handle writing or reading from disk, pushing data across a network, or anything like that — it will turn a message into bytes and read that same message back from the bytes, but you are responsible for what you do with them otherwise.

  With the given protocol, though, you could create a message in C# and write it to a file:
  ```csharp
  var msg = new AppMessages.Vector3Message();
  msg.x = 1.0f;
  msg.y = 4096.1234f;
  msg.z = -42.56f;
  var fs = new FileStream("./vec3.msg", FileMode.Create);
  var bw = new BinaryWriter(fs);
  msg.WriteBytes(bw, false);
  ```

  And then read it back in Go:
  ```golang
  dat, _ := os.Open("./vec3.msg")
  defer dat.Close()
  msg := AppMessages.Vector3MessageFromBytes(dat)
  if msg.X == 1.0 && msg.Y == 4096.1234 && msg.Z < 0.0 {
  	print("Ready to go!\n")
  }
  ```

  Or TypeScript:
  ```typescript
  const data = fs.readFileSync("./vec3.msg");
  const dv = new DataView(new Uint8Array(data).buffer);
  const msg = AppMessages.Vector3Message.fromBytes(dv, 0).val;
  if (msg.y == Math.fround(4096.1234)) {
      console.log("Ready to... typescript?");
  }
  ```


  For the most part, Beschi tries to keep behavior and structures consistent across the languages, but there are a few points of difference [outlined on the various language pages](https://github.com/sjml/beschi/tree/main/docs/languages). Notice in the example above, for instance, that in TypeScript you have to make a call to `Math.fround` if you want to do a straight comparison of float values because of how the underlying JavaScript engine treats all numbers as double-width floats. (Doing equality comparisons on floats is usually a bad idea, but in this instance we *want* to check that they are actually bitwise identical.) Similarly, see how the data members are upper-cased in Go to match that language's export conventions, and the byte reading function is part of the namespace because Go doesn't have static functions for data types. The goal is to make working across languages feel seamless, but there are some differences that we adapt to as much as possible.

  There are more extensive examples in [the test harnesses](https://github.com/sjml/beschi/tree/main/test/_harnesses).




  Beschi makes code that I use "in production" on personal projects. It could probably stand to be better optimized, there are probably edge cases and bugs, etc. But for the most part, this is mature enough that I stopped thinking of it as a project in itself and now it's just a tool that I use.

  I will admit that part of me wants to make new writers, but that's not likely to get done until I have a specific project motivating it. If someone loves this system, though, and really wants to see a generator for Haskell or Lua or whatever, go for it. The existing writers should be decent starting points — they aren't terribly clever (no AST or interesting data structures), just iterating over the protocol and writing out serialization/deserialization code.




  [Constanzo Giuseppe Beschi](https://en.wikipedia.org/wiki/Constanzo_Beschi) was an Italian Jesuit who worked in southern India during the early 18th century. He was noted as a talented linguist, able to tie concepts from multiple languages into a single form. At the same time, he was adept at the Jesuit principle of "inculturation," where foreign concepts are adapted for a new culture and the foreigner attempting the adaptation also respectfully adopts habits and ways of proceeding from the host culture.


pkgId: ea2b08cfd910192158ea6f9fabc690ad1e7f0bad7c7796b1dd29fb760d04168b
name: python-bespokelabs-curator-help
arch: noarch
version: 0.1.12
epoch: 0
release: 1
summary: Development documents and examples for bespokelabs-curator
url: https://github.com/bespokelabsai/curator
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bespokelabs-curator-0.1.12-1.src.rpm
location_href: Packages/python-bespokelabs-curator-help-0.1.12-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://bespokelabs.ai/" target="_blank">
      <picture>
        <source media="(prefers-color-scheme: light)" width="80px" srcset="https://raw.githubusercontent.com/bespokelabsai/curator/main/docs/Bespoke-Labs-Logomark-Red.png">
        <img alt="Bespoke Labs Logo" width="80px" src="https://raw.githubusercontent.com/bespokelabsai/curator/main/docs/Bespoke-Labs-Logomark-Red-on-Black.png">
      </picture>
    </a>
  </p>

  <h1 align="center">Bespoke Curator</h1>
  <h3 align="center" style="font-size: 20px; margin-bottom: 4px">Data Curation for Post-Training & Structured Data Extraction</h3>
  <br/>
  <p align="center">
    <a href="https://docs.bespokelabs.ai/">
      <img alt="Static Badge" src="https://img.shields.io/badge/Docs-docs.bespokelabs.ai-blue?style=flat&link=https%3A%2F%2Fdocs.bespokelabs.ai">
    </a>
    <a href="https://bespokelabs.ai/">
      <img alt="Site" src="https://img.shields.io/badge/Site-bespokelabs.ai-blue?link=https%3A%2F%2Fbespokelabs.ai"/>
    </a>
    <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/bespokelabs-curator">
    <a href="https://twitter.com/bespokelabsai">
      <img src="https://img.shields.io/twitter/follow/bespokelabsai" alt="Follow on X" />
    </a>
    <a href="https://discord.gg/KqpXvpzVBS">
      <img alt="Discord" src="https://img.shields.io/discord/1230990265867698186">
    </a>
    <a href="https://github.com/psf/black">
      <img alt="Code style: black" src="https://img.shields.io/badge/Code%20style-black-000000.svg">
    </a>
  </p>



  Bespoke Curator makes it very easy to create high-quality synthetic data at scale, which you can use to finetune models or use for structured data extraction at scale.

  Bespoke Curator is an open-source project:
  * That comes with a rich Python based library for generating and curating synthetic data.
  * A Curator Viewer which makes it easy to view the datasets, thus aiding in the dataset creation.
  * We will also be releasing high-quality datasets that should move the needle on post-training.



  1. **Programmability and Structured Outputs**: Synthetic data generation is lot more than just using a single prompt -- it involves calling LLMs multiple times and orchestrating control-flow. Curator treats structured outputs as first class citizens and helps you design complex pipelines.
  2. **Built-in Performance Optimization**: We often see calling LLMs in loops, or inefficient implementation of multi-threading. We have baked in performance optimizations so that you don't need to worry about those!
  3. **Intelligent Caching and Fault Recovery**: Given LLM calls can add up in cost and time, failures are undesirable but sometimes unavoidable. We cache the LLM requests and responses so that it is easy to recover from a failure. Moreover, when working on a multi-stage pipeline, caching of stages makes it easy to iterate.
  4. **Native HuggingFace Dataset Integration**: Work directly on HuggingFace Dataset objects throughout your pipeline. Your synthetic data is immediately ready for fine-tuning!
  5. **Interactive Curator Viewer**: Improve and iterate on your prompts using our built-in viewer. Inspect LLM requests and responses in real-time, allowing you to iterate and refine your data generation strategy with immediate feedback.



  ```bash
  pip install bespokelabs-curator
  ```


  To run the examples below, make sure to set your OpenAI API key in
  the environment variable `OPENAI_API_KEY` by running `export OPENAI_API_KEY=sk-...` in your terminal.



  ```python
  from bespokelabs import curator
  llm = curator.SimpleLLM(model_name="gpt-4o-mini")
  poem = llm("Write a poem about the importance of data in AI.")
  print(poem)

  poems = llm(["Write a poem about the importance of data in AI.",
              "Write a haiku about the importance of data in AI."])
  print(poems)
  ```
  Note that retries and caching are enabled by default.
  So now if you run the same prompt again, you will get the same response, pretty much instantly.
  You can delete the cache at `~/.cache/curator`.


  You can use the [LiteLLM](https://docs.litellm.ai/docs/providers) backend for calling other models.

  ```python
  from bespokelabs import curator
  llm = curator.SimpleLLM(model_name="claude-3-5-sonnet-20240620", backend="litellm")
  poem = llm("Write a poem about the importance of data in AI.")
  print(poem)
  ```


  Run `curator-viewer` on the command line to see the dataset in the viewer.

  You can click on a run and then click on a specific row to see the LLM request and response.
  ![Curator Responses](docs/curator-responses.png)
  More examples below.



  Let's use structured outputs to generate poems.
  ```python
  from bespokelabs import curator
  from datasets import Dataset
  from pydantic import BaseModel, Field
  from typing import List

  topics = Dataset.from_dict({"topic": [
      "Urban loneliness in a bustling city",
      "Beauty of Bespoke Labs's Curator library"
  ]})
  ```

  Define a class to encapsulate a list of poems.
  ```python
  class Poem(BaseModel):
      poem: str = Field(description="A poem.")

  class Poems(BaseModel):
      poems_list: List[Poem] = Field(description="A list of poems.")
  ```

  We define an `LLM` object that generates poems which gets applied to the topics dataset.
  ```python
  poet = curator.LLM(
      prompt_func=lambda row: f"Write two poems about {row['topic']}.",
      model_name="gpt-4o-mini",
      response_format=Poems,
      parse_func=lambda row, poems: [
          {"topic": row["topic"], "poem": p.poem} for p in poems.poems_list
      ],
  )
  ```
  Here:
  * `prompt_func` takes a row of the dataset as input and returns the prompt for the LLM.
  * `response_format` is the structured output class we defined above.
  * `parse_func` takes the input (`row`) and the structured output (`poems`) and converts it to a list of dictionaries. This is so that we can easily convert the output to a HuggingFace Dataset object.

  Now we can apply the `LLM` object to the dataset, which reads very pythonic.
  ```python
  poem = poet(topics)
  print(poem.to_pandas())






  ```
  Note that `topics` can be created with `curator.LLM` as well,
  and we can scale this up to create tens of thousands of diverse poems.
  You can see a more detailed example in the [examples/poem.py](https://github.com/bespokelabsai/curator/blob/mahesh/update_doc/examples/poem.py) file,
  and other examples in the [examples](https://github.com/bespokelabsai/curator/blob/mahesh/update_doc/examples) directory.

  See the [docs](https://docs.bespokelabs.ai/) for more details as well as
  for troubleshooting information.



  To run the bespoke dataset viewer:

  ```bash
  curator-viewer
  ```

  This will pop up a browser window with the viewer running on `127.0.0.1:3000` by default if you haven't specified a different host and port.

  The dataset viewer shows all the different runs you have made.
  ![Curator Runs](docs/curator-runs.png)

  You can also see the dataset and the responses from the LLM.
  ![Curator Dataset](docs/curator-dataset.png)


  Optional parameters to run the viewer on a different host and port:
  ```bash
  >>> curator-viewer -h
  usage: curator-viewer [-h] [--host HOST] [--port PORT] [--verbose]

  Curator Viewer

  options:
    -h, --help     show this help message and exit
    --host HOST    Host to run the server on (default: localhost)
    --port PORT    Port to run the server on (default: 3000)
    --verbose, -v  Enables debug logging for more verbose output
  ```

  The only requirement for running `curator-viewer` is to install node. You can install them by following the instructions [here](https://nodejs.org/en/download/package-manager).

  For example, to check if you have node installed, you can run:

  ```bash
  node -v
  ```

  If it's not installed, installing latest node on MacOS, you can run:

  ```bash

  curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash

  nvm install 22

  node -v # should print `v22.11.0`

  npm -v # should print `10.9.0`
  ```


  Contributions are welcome!


pkgId: 40dd931a432900357d280dc75358b111c880dd5b07739be3314e84a3671663dc
name: python-bespokelabs-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for bespokelabs
url: https://github.com/bespokelabsai/bespokelabs-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bespokelabs-0.2.1-1.src.rpm
location_href: Packages/python-bespokelabs-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/bespokelabs.svg)](https://pypi.org/project/bespokelabs/)

  The Bespoke Labs Python library provides convenient access to the Bespoke Labs REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [docs.bespokelabs.ai](https://docs.bespokelabs.ai/). The full API of this library can be found in [api.md](https://github.com/bespokelabsai/bespokelabs-python/tree/main/api.md).



  ```sh

  pip install bespokelabs
  ```



  The full API of this library can be found in [api.md](https://github.com/bespokelabsai/bespokelabs-python/tree/main/api.md).

  ```python
  import os
  from bespokelabs import BespokeLabs

  client = BespokeLabs(
      auth_token=os.environ.get("BESPOKE_API_KEY"),  # This is the default and can be omitted
  )

  factcheck = client.minicheck.factcheck.create(
      claim="claim",
      context="context",
  )
  print(factcheck.support_prob)
  ```

  While you can provide a `auth_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `BESPOKE_API_KEY="My Auth Token"` to your `.env` file
  so that your Auth Token is not stored in source control.



  Simply import `AsyncBespokeLabs` instead of `BespokeLabs` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from bespokelabs import AsyncBespokeLabs

  client = AsyncBespokeLabs(
      auth_token=os.environ.get("BESPOKE_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      factcheck = await client.minicheck.factcheck.create(
          claim="claim",
          context="context",
      )
      print(factcheck.support_prob)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `bespokelabs.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `bespokelabs.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `bespokelabs.APIError`.

  ```python
  import bespokelabs
  from bespokelabs import BespokeLabs

  client = BespokeLabs()

  try:
      client.minicheck.factcheck.create(
          claim="claim",
          context="context",
      )
  except bespokelabs.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except bespokelabs.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except bespokelabs.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from bespokelabs import BespokeLabs


  client = BespokeLabs(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).minicheck.factcheck.create(
      claim="claim",
      context="context",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from bespokelabs import BespokeLabs


  client = BespokeLabs(
      
      timeout=20.0,
  )


  client = BespokeLabs(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).minicheck.factcheck.create(
      claim="claim",
      context="context",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/bespokelabsai/bespokelabs-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `BESPOKE_LABS_LOG` to `info`.

  ```shell
  $ export BESPOKE_LABS_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from bespokelabs import BespokeLabs

  client = BespokeLabs()
  response = client.minicheck.factcheck.with_raw_response.create(
      claim="claim",
      context="context",
  )
  print(response.headers.get('X-My-Header'))

  factcheck = response.parse()  # get the object that `minicheck.factcheck.create()` would have returned
  print(factcheck.support_prob)
  ```

  These methods return an [`APIResponse`](https://github.com/bespokelabsai/bespokelabs-python/tree/main/src/bespokelabs/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/bespokelabsai/bespokelabs-python/tree/main/src/bespokelabs/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.minicheck.factcheck.with_streaming_response.create(
      claim="claim",
      context="context",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from bespokelabs import BespokeLabs, DefaultHttpxClient

  client = BespokeLabs(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/bespokelabsai/bespokelabs-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import bespokelabs
  print(bespokelabs.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/bespokelabsai/bespokelabs-python/tree/main/./CONTRIBUTING.md).


pkgId: 08c47037efbb7073b10c3c11e54df084a8544535308b972bd7d8c09d6588eb39
name: python-best403unlocker_py-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for best403unlocker_py
url: https://github.com/msnp1381/best403unlocker-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-best403unlocker_py-0.0.1-1.src.rpm
location_href: Packages/python-best403unlocker_py-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  The Python version of the 403 unlocker tool, available in [here](https://github.com/403unlocker/best403unlocker-py), has several key features:



  Built using Python's robust networking libraries and tools, providing excellent DNS handling capabilities and cross-platform support.



  Thanks to Python's portability, this project supports:

  - **Windows** (manual DNS configuration required)
  - **Linux** (automatic configuration)
  - **macOS** (automatic configuration)



  - Automated DNS speed testing
  - Progress bar visualization
  - Config file support
  - Both CLI and interactive modes





  ```bash
  pip install best403unlocker_py
  ```





  - Python 3.8 or higher
  - Poetry package manager
  - Administrative/root privileges (required for DNS configuration)



  1. Clone the repository:

  ```bash
  git clone https://github.com/403unlocker/best403unlocker-py.git
  cd best403unlocker-py
  ```

  2. Install dependencies using Poetry:

  ```bash
  poetry install
  ```





  This will:

  - Test all configured DNS servers
  - Display a progress bar during testing
  - Show results in a table format
  - Prompt to apply the fastest DNS server

  Command Line Options

  1. Test DNS servers with applying:

      ```bash
      unlock403 [--url URL]
      ```

  2. Test DNS servers without applying:

      ```bash
      unlock403 search-dns [--url URL]
      ```

  3. Set custom DNS servers:

     ```bash
     unlock403 set-custom-dns 8.8.8.8 8.8.4.4
     ```

  Examples
  Find fastest DNS for a specific domain:

  1. Default mode searche and set:

  ```bash
  unlock403
  ```

  2. Default mode searche and set with specific URL:

  ```bash
  unlock403 --url developers.google.com
  ```

  3. search with default url for dns:

  ```bash
  unlock403 search-dns
  ```

  4. search with custom url url for dns

  ```bash
  unlock403 search-dns --url developers.google.com
  ```



  Original concept by [Arman Taheri](https://github.com/ArmanTaheriGhaleTaki)



  Feel free to open issues and PRs on GitHub.

  [@msnp1381](https://github.com/msnp1381)
  OR
  [Email Me](mailto:mohamadnematpoor@gmail.com)


pkgId: 0849b7e1ba94189319d9bae073b87e8d70bfd6041dbda1b3a3a7cf86a466f89c
name: python-bgpy-pkg-help
arch: noarch
version: 12.1.1
epoch: 0
release: 1
summary: Development documents and examples for bgpy-pkg
url: https://github.com/jfuruness/bgpy_pkg
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bgpy-pkg-12.1.1-1.src.rpm
location_href: Packages/python-bgpy-pkg-help-12.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI Downloads](https://static.pepy.tech/badge/bgpy-pkg)
  [![PyPI version](https://badge.fury.io/py/bgpy_pkg.svg)](https://badge.fury.io/py/bgpy_pkg)
  ![PyPy](https://img.shields.io/badge/PyPy-7.3.17-blue)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bgpy_pkg)](https://pypi.org/project/bgpy_pkg/)
  ![Tests](https://github.com/jfuruness/bgpy/actions/workflows/tests.yml/badge.svg)
  ![Linux](https://img.shields.io/badge/os-Linux-blue.svg)
  ![macOS Intel](https://img.shields.io/badge/os-macOS_Intel-lightgrey.svg)
  ![macOS ARM](https://img.shields.io/badge/os-macOS_ARM-lightgrey.svg)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](https://img.shields.io/badge/mypy-checked-2A6DBA.svg)](http://mypy-lang.org/)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint/tree/main)
  [![try/except style: tryceratops](https://img.shields.io/badge/try%2Fexcept%20style-tryceratops%20%F0%9F%A6%96%E2%9C%A8-black)](https://github.com/guilatrova/tryceratops)



  Welcome to BGPy! One of the worlds leading Python BGP security simulators. You're in good company; this simulator has been used by teams all around the world, including NIST. BGPy is also [peer-reviewed research](https://dl.acm.org/doi/fullHtml/10.1145/3607505.3607509) and has been featured in [several publications](https://github.com/jfuruness/bgpy/wiki/Citations-and-Use-Cases), with many more ongoing.

  With BGPy, you can simulate the entire internet topology on your laptop. You can program your own security policies & attacks, use the topology for custom analysis, use real-world ROV data, etc. BGPy also comes with a custom test suite that allows for easy testing of security protocols. We support [more than 20 policies](https://github.com/jfuruness/bgpy_pkg/wiki/Routing-Policies) including ROV, ASPA,  and ASRA.

  If you're looking for an in depth tutorial as to the features, and how to use BGPy, I highly recommend the [tutorial](https://github.com/jfuruness/bgpy/wiki/Tutorial).

  If you're just looking to run/visualize attack/defense scenarios without programming, I recommend checking out the front-end for this tool: [BGPSimulator.com](https://www.bgpsimulator.com)

  If you're looking to cite BGPy or check out the use cases, you can find that [here](https://github.com/jfuruness/bgpy/wiki/Citations-and-Use-Cases). If you end up citing BGPy please let us know and we'll add you to the list :)



  * [Tutorial](https://github.com/jfuruness/bgpy/wiki/Tutorial)
  * [Citations and Use Cases](https://github.com/jfuruness/bgpy/wiki/Citations-and-Use-Cases)
  * [Installation](https://github.com/jfuruness/bgpy/wiki/Installation)
  * [Testing](https://github.com/jfuruness/bgpy/wiki/Testing)
  * [Development/Contributing](https://github.com/jfuruness/bgpy/wiki/Development-Contributing)
  * [History](https://github.com/jfuruness/bgpy/wiki/History)
  * [Credits](https://github.com/jfuruness/bgpy/wiki/Credits)
  * [License](https://github.com/jfuruness/bgpy/blob/master/LICENSE)
  * [FAQ](https://github.com/jfuruness/bgpy/wiki/FAQ)

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


pkgId: 129098578d64e1a5e18507d5d38a7b2add35c998595e7dc5d20cd61498223e54
name: python-bigdict-help
arch: noarch
version: 0.3.6
epoch: 0
release: 1
summary: Development documents and examples for bigdict
url: https://pypi.org/project/bigdict/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bigdict-0.3.6-1.src.rpm
location_href: Packages/python-bigdict-help-0.3.6-1.noarch.rpm
checksum_type: sha256
description:
  ``bigdict`` implements a persisted, out-of-memory dict for Python.
  The usage API strives to be as close as possible to the built-in ``dict``, with a small number of extras.
  The "engine", or "back-end", is currently ``lmdb``. However, ``lmdb`` is not the point; the point is rather a "persisted, out-of-memory dict". Criteria used in choosing the engine:
  - It must be *embedded*, as opposed to client/server.
  - It must be a mature project with a reliable Python binding.
  In addition,
  - It must use more files for storage as the data size grows, hence keeping file sizes controllable,
    as opposed to a single file growing unbounded.
  If the chosen backend does not meet this requirement, it's the responsibility of ``bigdict`` to implement that.
  Installation::
      $ pip install bigdict


pkgId: a378eb2a784186a4a82ad4eb3d2e7b2ae78a7d605a414dc693f947c7fa525882
name: python-bigeye-sdk-help
arch: noarch
version: 0.4.94
epoch: 0
release: 1
summary: Development documents and examples for bigeye-sdk
url: https://docs.bigeye.com/docs
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bigeye-sdk-0.4.94-1.src.rpm
location_href: Packages/python-bigeye-sdk-help-0.4.94-1.noarch.rpm
checksum_type: sha256
description:
  Bigeye SDK is a collection of protobuf generated code, functions, and models used to interact programmatically
  with the Bigeye API.  Bigeye currently supports a Python SDK.  The main entry point is the DatawatchClient
  abstraction and, in this core package, a basic auth client has been implemented.  The abstract base class
  includes core functionality (methods to interact with the API) and each implementation should enable a
  different authorization methods.



  ```shell
  pip install bigeye_sdk
  ```



  Basic authorization credentials can be stored as Json either on disk or in a secrets/credentials manager.  This
  format will be marshalled into an instance of [BasicAuthRequestLibApiConf](bigeye_sdk/authentication/api_authentication.py).

  ```json
  {
      "base_url": "https://app.bigeye.com",
      "user": "",
      "password": ""
  }
  ```


pkgId: d54b6884197462beb9e44a743cc34cfab09a3c0b6865ef343e7a50452f94a8b9
name: python-bigquery-duckdb-toolkit-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for bigquery-duckdb-toolkit
url: https://github.com/ResultadosDigitais/bigquery_duckdb_toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bigquery-duckdb-toolkit-1.0.3-1.src.rpm
location_href: Packages/python-bigquery-duckdb-toolkit-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  `bigquery_duckdb_toolkit` é um pacote Python desenvolvido para facilitar o carregamento de dados do BigQuery e a execução de consultas SQL flexíveis no DuckDB. Ele permite carregar dados de qualquer tabela do BigQuery em um DataFrame pandas e realizar análises avançadas no DuckDB, sendo ideal para workflows de analytics engineering.



  Para instalar a partir do PyPI, execute:

  ```bash
  pip install bigquery_duckdb_toolkit
  ```



  ```plaintext
  bigquery_duckdb_toolkit/
  ├── bigquery_duckdb_toolkit/
  │   ├── __init__.py
  │   ├── bigquery_client.py
  │   ├── bigquery_to_pandas.py
  │   └── interaction_service.py
  ├── setup.py
  ├── requirements.txt
  └── README.md
  ```



  - **`BigQueryClient`**: Estabelece uma conexão com o BigQuery e executa consultas SQL.
  - **`BigQueryToPandas`**: Carrega dados do BigQuery em um DataFrame pandas e aplica filtros e conversões de tipo.
  - **`InteractionService`**: Carrega dados de qualquer tabela do BigQuery, registra-os no DuckDB e executa consultas SQL personalizadas.



  Neste exemplo, usaremos o conjunto de dados público `bigquery-public-data.samples.natality`, que contém dados de natalidade nos Estados Unidos. Vamos carregar dados para um DataFrame pandas, registrá-los no DuckDB e realizar uma consulta personalizada.

  > Nota: Caso deseje filtrar por alguma chave primário ou estrangeira, utilizar o valor como string.

  ```python
  from bigquery_duckdb_toolkit.interaction_service import InteractionService


  project_id = 'bigquery-public-data'
  table_name = 'bigquery-public-data.samples.natality'


  interaction_service = InteractionService(project_id)


  filters = {"year": "2000", "state": "CA"}  # Exemplo de filtro para registros de 2000 na Califórnia
  df = interaction_service.load_data_to_duckdb(table_name, filters, duckdb_table_name='natality')



  query = """
    SELECT month, COUNT(*) AS births_count
    FROM natality
    GROUP BY month
    ORDER BY births_count DESC
  """
  result_df = interaction_service.run_duckdb_query(query)


  interaction_service.display_query_results(query)
  ```





  - **`load_data_to_duckdb(table_name, filters=None, duckdb_table_name='temp_table')`**:
    Carrega dados de uma tabela BigQuery em um DataFrame pandas com filtros opcionais e registra-o como uma tabela no DuckDB.

    - **Parâmetros**:
      - `table_name` (str): Nome da tabela BigQuery no formato `project.dataset.table`.
      - `filters` (dict, opcional): Dicionário com filtros para aplicar à consulta. Exemplo: `{"coluna": "valor"}`.
      - `duckdb_table_name` (str, opcional): Nome para registrar a tabela no DuckDB (padrão: `'temp_table'`).

    - **Retorno**: `pd.DataFrame` com os dados filtrados.

  - **`run_duckdb_query(query)`**: Executa uma consulta SQL no DuckDB e retorna os resultados em um DataFrame pandas.

    - **Parâmetros**:
      - `query` (str): Consulta SQL a ser executada.

    - **Retorno**: `pd.DataFrame` com os resultados da consulta.

  - **`display_query_results(query)`**: Executa uma consulta SQL no DuckDB e exibe os resultados, útil para visualização em notebooks.

    - **Parâmetros**:
      - `query` (str): Consulta SQL a ser executada.



  Contribuições são bem-vindas! Abra issues e pull requests conforme necessário. Para contribuições maiores, entre em contato para discutir as mudanças propostas.



  Este projeto está licenciado sob a licença MIT. Consulte o arquivo `LICENSE` para mais detalhes.


pkgId: 0b1c8520d1d83c8300e345ad98df88d4e2e26febebceca503f7b9cc4047c77f6
name: python-bigquery-magics-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for bigquery-magics
url: https://github.com/googleapis/python-bigquery-magics
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bigquery-magics-0.5.0-1.src.rpm
location_href: Packages/python-bigquery-magics-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  |GA| |pypi| |versions|
  Querying massive datasets can be time consuming and expensive without the
  right hardware and infrastructure. Google `BigQuery`_ solves this problem by
  enabling super-fast, SQL queries against append-mostly tables, using the
  processing power of Google's infrastructure.
  -  `Library Documentation`_
  -  `Product Documentation`_


pkgId: 1ed881d2ed56ca8b945204eb7d643a8cb8046b81569b8d7704aa232b6ade2b1d
name: python-bigquery-migrations-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for bigquery-migrations
url: https://github.com/RolandBende/python-bigquery-migrations
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bigquery-migrations-0.4.1-1.src.rpm
location_href: Packages/python-bigquery-migrations-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  Python bigquery-migrations package is for creating and manipulating BigQuery databases easily.

  Migrations are like version control for your database, allowing you to define and share the application's datasets and table schema definitions.



  ```
  your-project
  ├── credentials
  │   ├── gcp-sa.json
  ├── migrations
  │   ├── 2024_12_01_120000_create_users_table.py
  ├── src
  │   ├── my_project_file.py
  └── README.md
  ```



  Put your service account JSON file in the credentials subdirectory in the root of your project.

  ```
  your-project
  ├── credentials
  │   ├── gcp-sa.json
  ...
  ```



  Put your migrations files in the migrations subdirectory of the root of your project.

  ```
  your-project
  ├── migrations
  │   ├── 2024_12_01_120000_create_users_table.py
  ...
  ```



  The migration class must contain two methods: `up` and `down`.

  The `up` method is used to add new dataset, tables, columns etc. to your BigQuery project, while the `down` method should reverse the operations performed by the up method.

  ```python
  from google.cloud import bigquery
  from src.bigquery_migrations.migration import Migration

  class CreateUsersTable(Migration):
      """
      See:
      https://github.com/googleapis/python-bigquery/tree/main/samples
      """

      def up(self):
          
          table_id = "your_project.your_dataset.example_table"

          
          schema = [
              bigquery.SchemaField("id", "INTEGER", mode="REQUIRED"),
              bigquery.SchemaField("name", "STRING", mode="REQUIRED"),
              bigquery.SchemaField("created_at", "TIMESTAMP", mode="NULLABLE"),
          ]
          table = bigquery.Table(table_id, schema=schema)
          table = self.client.create_table(table)
          print(
              "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
          )

      def down(self):
          
          table_id = "your_project.your_dataset.example_table"

          
          
          self.client.delete_table(table_id, not_found_ok=True)
          print("Deleted table '{}'.".format(table_id))
  ```



  To run all of your outstanding migrations, execute the `run` command:

  ```bash
  bigquery-migrations run
  ```

  You can specify the Google Cloud Project id witth the `--gcp-project-id` argument:

  ```bash
  bigquery-migrations run --gcp-project-id
  ```



  To reverse all of your migrations, execute the `reset` command:

  ```bash
  bigquery-migrations reset
  ```






  - README.md sample code: removed unnecessary lines of code



  This is the first release which uses the `CHANGELOG` file.

rpm_license:
  MIT License  Copyright (c) 2024 Roland Bende  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: 34abfeb174c57691b77b10d1d192e084293c15bde0bfc2863ea90cd876f85e4b
name: python-biliup-help
arch: noarch
version: 0.4.79
epoch: 0
release: 1
summary: Development documents and examples for biliup
url: https://github.com/ForgQi/bilibiliupload
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-biliup-0.4.79-1.src.rpm
location_href: Packages/python-biliup-help-0.4.79-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://image.biliup.me/2024-06-26/1719388842-365149-logo.png" width="400" alt="logo">
  </p>

  <div align="center">

  [![python](https://img.shields.io/badge/python-3.7%2B-blue)](http://www.python.org/download)
  [![PyPI](https://img.shields.io/pypi/v/biliup)](https://pypi.org/project/biliup)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/biliup)](https://pypi.org/project/biliup)
  [![license](https://img.shields.io/github/license/biliup/biliup)](https://github.com/biliup/biliup/blob/master/LICENSE)
  [![Telegram](https://img.shields.io/badge/Telegram-Group-blue.svg?logo=telegram)](https://t.me/+IkpIABHqy6U0ZTQ5)


  [![issues](https://img.shields.io/github/issues/biliup/biliup?label=Github%20issues)](https://github.com/biliup/biliup/issues)
  [![STARS](https://img.shields.io/github/stars/biliup/biliup)](https://github.com/biliup/biliup/stargazers)
  [![forks](https://img.shields.io/github/forks/biliup/biliup)](https://github.com/biliup/biliup/network)

  </div>




    <p align="center">
      录制各大主流直播平台并上传至哔哩哔哩弹幕网<br />
    自动选择上传线路，保证上传稳定性，可手动调整并发<br />
      支持录制哔哩哔哩、斗鱼、虎牙、Twitch直播弹幕用于外挂播放器<br />
   防止录制花屏（使用默认的stream-gears下载器就会有这个功能），解决网络、PK导致的花屏。


  <br />
      <a href="https://biliup.github.io/biliup/docs/guide/changelog"><strong>更新日志 »</strong></a>
      <br />
      <br />
      <a href="https://github.com/biliup/biliup/wiki/%E5%AE%89%E8%A3%85-%E8%BF%90%E8%A1%8C-%E6%9B%B4%E6%96%B0-%E5%8D%B8%E8%BD%BD">简易教程</a>
      ·
      <a href="https://biliup.me/">交流社区</a>
      ·
      <a href="https://github.com/biliup/biliup-app">投稿工具</a>
    </p>
  </div>





  <p align="center">
    <b>社区教程</b>: <a href="https://www.bilibili.com/opus/908292536945082370">图文教程</a> by <a href="https://github.com/ikun1993">@ikun1993</a>编写。
  </p>




  下载 exe: [Release](https://github.com/biliup/biliup/releases/latest)


  0. python`version >= 3.8`
  1. `pip3 install biliup`
  2. `biliup start`
  3. 启动时访问 `http://your-ip:19159` 使用webUI，


  ```sh
  docker run -d \
    --name biliup \
    --restart unless-stopped \
    -p 0.0.0.0:19159:19159 \
    -v /path/to/save_folder:/opt \
    ghcr.io/biliup/caution:latest \
    --password password123
  ```

  * 用户名为`biliup`
  * 暴露在公网中也许会产生风险，所以设置密码是很有必要的。
  * 以上示例根据需求进行修改，只作为参考。

  * * * * * * * * *


  ![](.github/resource/light.png)
  ![](.github/resource/dark.png)



  1. nodejs `version >= 18`
  2. `npm i`
  3. `npm run dev`
  4. `python3 -m biliup`
  5. 访问`http://localhost:3000`



  | 直播平台 | 支持类型      | 链接示例 | 特殊注释 |
  | :------:| :--------------: | --------- | ------ |
  | 虎牙 | 直播 | `https://www.huya.com/123456` | 可录制弹幕 |
  | 斗鱼 | 直播 | `https://www.douyu.com/123456` | 可录制弹幕 |
  | YY语音 | 直播 | `https://www.yy.com/123456` |
  | 哔哩哔哩 | 直播 | `https://live.bilibili.com/123456` | 特殊分区hls流需要单独配置/可录制弹幕 |
  | acfun | 直播 | `https://live.acfun.cn/live/123456` |
  | afreecaTV | 直播 | `https://play.afreecatv.com/biliup123/123456` | 录制部分直播时需要登陆 |
  | bigo | 直播 | `https://www.bigo.tv/123456` |
  | 抖音 | 直播 | 直播:`https://live.douyin.com/123456(直播间数字号)`<br>直播:`https://live.douyin.com/tiktok(抖音号)`<br>主页:`https://www.douyin.com/user/456789(抖音号)` | 使用主页链接或被风控需配置cookies |
  | 快手 | 直播 | `https://live.kuaishou.com/u/biliup123` | 监控开播需使用中国大陆IPv4家宽，<br>且24小时内单直播间最多120次请求 |
  | 网易CC | 直播 | `https://cc.163.com/123456` |
  | flextv | 直播 | `https://www.flextv.co.kr/channels/123456/live` |
  | 映客 | 直播 | `https://www.inke.cn/liveroom/index.html?uid=123456` |
  | 猫耳FM | 直播 | `https://fm.missevan.com/live/123456` | 猫耳为纯音频流 |
  | nico | 直播 | `https://live.nicovideo.jp/watch/lv123456` | 可配置登录信息 |
  | twitch | 直播<br>回放 | 直播:`https://www.twitch.tv/biliup123`<br>回放:`https://www.twitch.tv/biliup123/videos?filter=archives&sort=time`  | 可配置登录信息/尽量录制回放/可录制弹幕 |
  | youtube | 直播<br>回放 | 直播:`https://www.youtube.com/watch?v=biliup123(单场)`<br>直播:`https://www.youtube.com/@biliup123/live(最远的预约)`<br>回放:`https://www.youtube.com/@biliup123/videos` | 可配置登录信息/尽量录制回放/可配置回放下载日期 |
  * 理论上streamlink与yt-dlp支持的都可以下载，但不保证可以正常使用，详见:[streamlink支持列表](https://streamlink.github.io/plugins.html)，[yt-dlp支持列表](https://github.com/yt-dlp/yt-dlp/tree/master/yt_dlp/extractor).



  * Thanks `ykdl, youtube-dl, streamlink` provides downloader.
  * Thanks `THMonster/danmaku`.



  * 爱发电 :`https://afdian.net/a/biliup`



  [![Star History Chart](https://api.star-history.com/svg?repos=biliup/biliup&type=Date)](https://star-history.com/#biliup/biliup&Date)


pkgId: 94e15e434402bcb6c3a0bfbe4d7e14ff3e87e275759aac62d60b6592851ac343
name: python-binance-connector-help
arch: noarch
version: 3.11.0
epoch: 0
release: 1
summary: Development documents and examples for binance-connector
url: https://github.com/binance/binance-connector-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-binance-connector-3.11.0-1.src.rpm
location_href: Packages/python-binance-connector-help-3.11.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/binance-connector)](https://pypi.python.org/pypi/binance-connector)
  [![Python version](https://img.shields.io/pypi/pyversions/binance-connector)](https://www.python.org/downloads/)
  [![Documentation](https://img.shields.io/badge/docs-latest-blue)](https://binance-connector.readthedocs.io/en/stable/)
  [![Code Style](https://img.shields.io/badge/code_style-black-black)](https://black.readthedocs.io/en/stable/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  This is a lightweight library that works as a connector to [Binance public API](https://github.com/binance/binance-spot-api-docs)

  - Supported APIs:
      - `/api/*`
      - `/sapi/*`
      - Spot Websocket Market Stream
      - Spot User Data Stream
      - Spot WebSocket API
  - Inclusion of test cases and examples
  - Customizable base URL, request timeout and HTTP proxy
  - Response metadata can be displayed



  ```bash
  pip install binance-connector
  ```



  [https://binance-connector.readthedocs.io](https://binance-connector.readthedocs.io)



  Usage examples:
  ```python
  from binance.spot import Spot

  client = Spot()


  print(client.time())

  print(client.klines("BTCUSDT", "1m"))

  print(client.klines("BNBUSDT", "1h", limit=10))


  client = Spot(api_key='<api_key>', api_secret='<api_secret>')


  print(client.account())


  params = {
      'symbol': 'BTCUSDT',
      'side': 'SELL',
      'type': 'LIMIT',
      'timeInForce': 'GTC',
      'quantity': 0.002,
      'price': 9500
  }

  response = client.new_order(**params)
  print(response)
  ```
  Please find `examples` folder to check for more endpoints.
  - In order to set your API and Secret Key for use of the examples, create a file `examples/config.ini` with your keys.
  - Eg:
      ```ini
      
      [keys]
      api_key=abc123456
      api_secret=cba654321
      ```



  Binance supports HMAC, RSA and ED25519 API authentication.

  ```python


  client = Client(api_key, api_secret)
  print(client.account())


  client = Client(api_key=api_key, private_key=private_key)
  print(client.account())


  api_key = ""
  private_key = "./private_key.pem"
  private_key_pass = "<password_if_applicable>"

  with open(private_key, 'rb') as f:
      private_key = f.read()

  spot_client = Client(api_key=api_key, private_key=private_key, private_key_pass=private_key_pass)


  client = Client(api_key=api_key, private_key=private_key, private_key_pass='password')
  print(client.account())
  ```
  Please find `examples/spot/wallet/account_snapshot.py` for more details on ED25519.
  Please find `examples/spot/trade/get_account.py` for more details on RSA.



  [Spot Testnet](https://testnet.binance.vision/) is available, it can be used to test `/api/*` endpoints.

  - `/sapi/*` endpoints are not available.
  - No UI.
  - Steps to setup testnet API key.  [https://dev.binance.vision/t/99](https://dev.binance.vision/t/99)

  To use testnet:
  ```python
  from binance.spot import Spot as Client

  client = Client(base_url='https://testnet.binance.vision')
  print(client.time())
  ```



  If `base_url` is not provided, it defaults to `api.binance.com`.<br/>
  It's recommended to pass in the `base_url` parameter, even in production as Binance provides alternative URLs
  in case of performance issues:
  - `https://api1.binance.com`
  - `https://api2.binance.com`
  - `https://api3.binance.com`



  PEP8 suggests _lowercase with words separated by underscores_, but for this connector,
  the methods' optional parameters should follow their exact naming as in the API documentation.

  ```python

  response = client.cancel_oco_order('BTCUSDT', orderListId=1)


  response = client.cancel_oco_order('BTCUSDT', order_list_id=1)
  ```



  Additional parameter `recvWindow` is available for endpoints requiring signature.<br/>
  It defaults to `5000` (milliseconds) and can be any value lower than `60000`(milliseconds).
  Anything beyond the limit will result in an error response from Binance server.

  ```python
  from binance.spot import Spot as Client

  client = Client(api_key, api_secret)
  response = client.get_order('BTCUSDT', orderId=11, recvWindow=10000)
  ```



  `timeout` is available to be assigned with the number of seconds you find most appropriate to wait for a server response.<br/>
  Please remember the value as it won't be shown in error message _no bytes have been received on the underlying socket for timeout seconds_.<br/>
  By default, `timeout` is None. Hence, requests do not time out.

  ```python
  from binance.spot import Spot as Client

  client= Client(timeout=1)
  ```



  The `time_unit` parameter is optional and allows you to retrieve data with timestamps in `microsecond` or `millisecond`. Users can set it with the following values:
  - `microsecond`
  - `millisecond`
  - `MICROSECOND`
  - `MILLISECOND`

  By default, `time_unit` is set to `None` and will return a timestamp values in milliseconds.

  ```python
  from binance.spot import Spot as Client

  client = Client(time_unit="microsecond")
  ```



  Proxy is supported.

  ```python
  from binance.spot import Spot as Client

  proxies = { 'https': 'http://1.2.3.4:8080' }

  client= Client(proxies=proxies)
  ```




  The Binance API server provides weight usages in the headers of each response.
  You can display them by initializing the client with `show_limit_usage=True`:

  ```python
  from binance.spot import Spot as Client

  client = Client(show_limit_usage=True)
  print(client.time())
  ```
  returns:

  ```python
  {'data': {'serverTime': 1587990847650}, 'limit_usage': {'x-mbx-used-weight': '31', 'x-mbx-used-weight-1m': '31'}}
  ```
  You can also display full response metadata to help in debugging:

  ```python
  client = Client(show_header=True)
  print(client.time())
  ```

  returns:

  ```python
  {'data': {'serverTime': 1587990847650}, 'header': {'Context-Type': 'application/json;charset=utf-8', ...}}
  ```

  If `ClientError` is received, it'll display full response meta information.



  Setting the log level to `DEBUG` will log the request URL, payload and response text.



  There are 2 types of error returned from the library:
  - `binance.error.ClientError`
      - This is thrown when server returns `4XX`, it's an issue from client side.
      - It has 5 properties:
          - `status_code` - HTTP status code
          - `error_code` - Server's error code, e.g. `-1102`
          - `error_message` - Server's error message, e.g. `Unknown order sent.`
          - `header` - Full response header.
          - `error_data`* - Additional detailed data which supplements the `error_message`.
              - **Only applicable on select endpoints, eg. `cancelReplace`*
  - `binance.error.ServerError`
      - This is thrown when server returns `5XX`, it's an issue from server side.





  WebSocket can be established through either of the following types of connections:
  - WebSocket API (`https://github.com/binance/binance-spot-api-docs/blob/master/web-socket-api.md`)
  - WebSocket Stream (`https://github.com/binance/binance-spot-api-docs/blob/master/web-socket-streams.md`)

  ```python


  from binance.websocket.spot.websocket_api import SpotWebsocketAPIClient

  def message_handler(_, message):
      logging.info(message)

  my_client = SpotWebsocketAPIClient(on_message=message_handler)

  my_client.ticker(symbol="BNBBUSD", type="FULL")

  time.sleep(5)
  logging.info("closing ws connection")
  my_client.stop()
  ```

  ```python


  from binance.websocket.spot.websocket_stream import SpotWebsocketStreamClient

  def message_handler(_, message):
      logging.info(message)

  my_client = SpotWebsocketStreamClient(on_message=message_handler)


  my_client.agg_trade(symbol="bnbusdt")
  time.sleep(5)
  logging.info("closing ws connection")
  my_client.stop()
  ```



  The `time_unit` parameter is optional and allows you to retrieve data with timestamps in `microsecond` or `millisecond`. Users can set it with the following values:
  - `microsecond`
  - `millisecond`
  - `MICROSECOND`
  - `MILLISECOND`

  By default, `time_unit` is set to `None` and will return a timestamp values in milliseconds.

  ```python

  import logging
  from binance.websocket.spot.websocket_api import SpotWebsocketAPIClient

  def message_handler(_, message):
      logging.info(message)


  my_client = SpotWebsocketAPIClient(on_message=message_handler, time_unit='microsecond')
  ```

  ```python

  import logging
  from binance.websocket.spot.websocket_stream import SpotWebsocketStreamClient

  def message_handler(_, message):
      logging.info(message)

  my_client = SpotWebsocketStreamClient(on_message=message_handler, time_unit="microsecond")
  ```



  Proxy is supported for both WebSocket API and WebSocket Stream.

  To use it, pass in the `proxies` parameter when initializing the client.

  The format of the `proxies` parameter is the same as the one used in the Spot RESTful API.

  It consists on a dictionary with the following format, where the key is the type of the proxy and the value is the proxy URL:

  For websockets, the proxy type is `http`.

  ```python
  proxies = { 'http': 'http://1.2.3.4:8080' }
  ```

  You can also use authentication for the proxy by adding the `username` and `password` parameters to the proxy URL:

  ```python
  proxies = { 'http': 'http://username:password@host:port' }
  ```


  ```python


  from binance.websocket.spot.websocket_api import SpotWebsocketAPIClient

  def message_handler(_, message):
      logging.info(message)

  proxies = { 'http': 'http://1.2.3.4:8080' }

  my_client = SpotWebsocketAPIClient(on_message=message_handler, proxies=proxies, timeout=10)

  my_client.ticker(symbol="BNBBUSD", type="FULL")

  time.sleep(5)
  logging.info("closing ws connection")
  my_client.stop()
  ```

  ```python


  from binance.websocket.spot.websocket_stream import SpotWebsocketStreamClient

  def message_handler(_, message):
      logging.info(message)

  proxies = { 'http': 'http://1.2.3.4:8080' }

  my_client = SpotWebsocketStreamClient(on_message=message_handler, proxies=proxies, timeout=10)


  my_client.agg_trade(symbol="bnbusdt")
  time.sleep(5)
  logging.info("closing ws connection")
  my_client.stop()
  ```



  Client can assign a request id to each request. The request id will be returned in the response message. Not mandatory in the library, it generates a uuid format string if not provided.

  ```python

  my_client.ping_connectivity(id="my_request_id")


  my_client.ping_connectivity()
  ```


  - If you set `is_combined` to `True`, `"/stream/"` will be appended to the `baseURL` to allow for Combining streams.
  - `is_combined` defaults to `False` and `"/ws/"` (raw streams) will be appended to the `baseURL`.

  More websocket examples are available in the `examples` folder.

  Example file "examples/websocket_api/app_demo.py" demonstrates how Websocket API and Websocket Stream can be used together.



  ```python
  from binance.websocket.spot.websocket_client import SpotWebsocketClient as WebsocketClient

  def message_handler(message):
      print(message)

  ws_client = WebsocketClient()
  ws_client.start()

  ws_client.mini_ticker(
      symbol='bnbusdt',
      id=1,
      callback=message_handler,
  )


  ws_client.instant_subscribe(
      stream=['bnbusdt@bookTicker', 'ethusdt@bookTicker'],
      callback=message_handler,
  )

  ws_client.stop()
  ```



  Once connected, the websocket server sends a ping frame every 3 minutes and requires a response pong frame back within
  a 10 minutes period. This package handles the pong responses automatically.



  ```python
  from binance.websocket.spot.websocket_client import SpotWebsocketClient as WebsocketClient

  ws_client = WebsocketClient(stream_url='wss://stream.testnet.binance.vision')
  ```



  ```python

  pip install -r requirements/requirements-test.txt

  python -m pytest tests/
  ```



  Futures and Vanilla Options APIs are not supported:
    - `/fapi/*`
    - `/dapi/*`
    - `/vapi/*`
    -  Associated Websocket Market and User Data Streams



  Contributions are welcome.<br/>
  If you've found a bug within this project, please open an issue to discuss what you would like to change.<br/>
  If it's an issue with the API, please open a topic at [Binance Developer Community](https://dev.binance.vision)


pkgId: ac3047b499a923912df56deb7b4886e48d0791516705ac0f3d39d470187407ae
name: python-binary-refinery-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for binary-refinery
url: https://github.com/binref/refinery/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-binary-refinery-0.8.0-1.src.rpm
location_href: Packages/python-binary-refinery-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
                           \  /
                            \/
  ```
  The Binary Refinery&trade; is a collection of Python scripts that implement transformations of binary data such as compression and encryption.
  We will often refer to it simply by _refinery_, which is also the name of the corresponding package.
  The scripts are designed to exclusively read input from stdin and write output to stdout.
  The main philosophy is that every script should be a unit in the sense that it does _one_ job,
  and individual units can be combined into _pipelines_ with the piping operator `|` on the commandline to perform more complex tasks.
  The project's main focus is malware triage,
  and is an attempt to implement something like [CyberChef](https://github.com/gchq/CyberChef) on the commandline.

  Make a Python virtual environment. You need Python 3.8 or later. Install refinery like this:
  ```
  pip install binary-refinery[extended]
  ```
  Run units with `-h` to learn how they work, grep through the [docs][] or use the command `binref` to find them.
  Watch [the latest video][VOD3] if you want to see it in action.
  But also, read the rest of this readme.

  The help text that is displayed when executing a unit with the `-h` or `--help` switch is its main documentation.
  The [automatically generated documentation][docs] contains a compilation of that output for each unit at the top level,
  but also contains the specification for the three fundamental concepts of the toolkit:
  [framing][frame], [multibin arguments][argformats], and [meta variables][meta].
  Full-text search of the description and help text for every unit is also available on the command line,
  via the provided `binref` command. In recognition of the fact that reference documentation can be somewhat dry,
  there is an ongoing effort to produce a series of [tutorials](https://github.com/binref/refinery/blob/master/tutorials); I very much recommend to check them out.
  On top of that, I collect additional resources (including some produced by third parties) below.
  > [!NOTE]
  > Refinery is still in alpha and the interface can sometimes change,
  > i.e. units and parameters can be removed or renamed.
  > Hence, it can happen that specific command lines from older videos and blog posts don't work any more.
  - [`2021/08`] [OALabs][OA] was kind enough to let me [demo the toolkit in a feature video][VOD1].
    In the video, I essentially work through the contents of
    [the first tutorial](https://github.com/binref/refinery/blob/master/tutorials/tbr-files.v0x01.netwalker.dropper.ipynb).
  - [`2021/11`] [Johannes Bader][JB] wrote an amazing [blog post][BLOG] about analyzing malspam with binary refinery.
  - [`2024/03`] [Malware Analysis For Hedgehogs][MH] made [a video about unpacking an XWorm sample][VOD2] using refinery.
  - [`2024/11`] [the CyberYeti][CY] had me [on stream presenting refinery][VOD3].
    Showcases again include samples from the example section below and the [tutorials](https://github.com/binref/refinery/blob/master/tutorials).

  The Binary Refinery is (c) 2019 Jesko Hüttenhain, and published under a [3-Clause BSD License][license].
  This repository also contains [a copy of the full license text](https://github.com/binref/refinery/blob/master/LICENSE).
  If you want to do something with it that's not covered by this license, please feel free to contact the author.

  The refinery requires at least **Python 3.8**.
  It is recommended to install it into its own [virtual environment][venv]:
  The package can pull in a **lot** of dependencies,
  and installing it into your global Python is somewhat prone to version conflicts.
  Also, since the toolkit introduces a large number of new commands,
  there is a good chance that some of these will clash on some systems,
  and keeping them in their own separate virtual environment is one way to prevent that.
  If you want to have all refinery commands available in your shell at all times (i.e. without having to switch to a custom virtual environment),
  you also have the option to choose a _prefix_ for the installation,
  which will be put in front of every command shim that is installed.
  For example, if you choose `r.` as your prefix, then the [emit][] unit will be installed as the command `r.emit`.
  An added benefit is that you can type `r.` and hammer <kbd>Tab</kbd> twice to get a list of all available refinery commands.
  Note however that no prefix is assumed in documentation and it is a development goal of refinery to _not_ clash on most systems.
  The author does not use a prefix and provides this option as a safety blanket.

  The most straightforward way to install and update refinery is via pip:
  ```
  pip install -U binary-refinery
  ```
  If you want to choose a prefix for all units, you can specify it via the environment variable `REFINERY_PREFIX`.
  For example, the following command will install refinery into the current Python environment with prefix `r.` on Linux:
  ```bash
  REFINERY_PREFIX=r. pip install -U binary-refinery
  ```
  On Windows, you would have to run the following commands:
  ```batch
  set REFINERY_PREFIX=r.
  pip install -U binary-refinery
  ```
  Specifying the special prefix `!` will have the effect that no shell commands are created at all,
  and binary refinery will be installed only as a library.
  If you want to install the current refinery `HEAD`, you can repeat all of the above steps, specifying this repository instead of the pip package.
  For example, the following will install the very latest refinery commit:
  ```
  pip install -U git+git://github.com/binref/refinery.git
  ```
  Finally, if you are using [REMnux][remnux-main], you can use their [refinery docker container][remnux].

  The following is a summary of how well various shell environments are currently supported:
  | Shell      | Platform | State           | Comment                                                          |
  |:-----------|:---------|:----------------|:-----------------------------------------------------------------|
  | Bash       | Posix    | 🔵 Good         | Used occasionally by the author.                                 |
  | CMD        | Windows  | 🔵 Good         | Used extensively by the author.                                  |
  | PowerShell | Windows  | 🟡 Reasonable   | It [just works if the PowerShell version is at least 7.4.][psh1] |
  | Zsh        | Posix    | 🟠 Minor Issues | Following a [discussion][zsh1], there is a [fix][zsh2].          |
  | Fish       | Posix    | 🟠 Minor Issues | See issue [#55][fsh1] and discussion [#22][fsh2].                |
  If you are using a different shell and have some feedback to share, please [let me know](https://github.com/binref/refinery/discussions)!

  There are some units that have rather heavy-weight dependencies.
  For example, [pcap][] is the only unit that requires a packet capture file parsing library.
  These libraries are not installed by default to keep the installation time for refinery at a reasonable level for first-time users.
  The corresponding units will tell you what to do when their dependency is missing:
  ```
  $ emit archive.7z | xt7z -l
  (13:37:00) failure in xt7z: dependency py7zr is missing; run pip install py7zr
  ```
  You can then install these missing dependencies manually.
  If you do not want to be bothered by missing dependencies and don't mind a long refinery installation, you can install the package as follows:
  ```
  pip install -U binary-refinery[all]
  ```
  which will install _all_ dependencies on top of the required ones.
  More precisely, there are the following extra categories available:
  |       Name | Included Dependencies                                             |
  |-----------:|:------------------------------------------------------------------|
  |      `all` | all dependencies for all refinery units                           |
  |      `arc` | all archiving-related dependencies (i.e. 7zip support)            |
  |  `default` | recommended selection of reasonable dependencies, author's choice |
  |  `display` | the packages `colorama` and `jsbeautifier`                        |
  | `extended` | an extended selection, excluding only the most heavyweight ones   |
  |  `formats` | all dependencies related to parsing of various file formats       |
  |   `office` | subset of `formats`; all office-related parsing dependencies      |
  |   `python` | packages related to Python decompilation                          |
  You can specify any combination of these to the installation to have some control over trading dependencies for capabilities.

  Alternatively, you can clone this repository and use the scripts [update.sh](https://github.com/binref/refinery/blob/master/update.sh) (on Linux) or [update.ps1](https://github.com/binref/refinery/blob/master/update.ps1) (on Windows) to install the refinery package into a local virtual environment.
  The installation and update process for this method is to simply run the script:
  - it pulls the repository,
  - activates the virtual environment,
  - uninstalls `binary-refinery`,
  - and then installs `binary-refinery[all]`.

  You can also generate all documentation locally.
  To do so, execute the [run-pdoc3.py](https://github.com/binref/refinery/blob/master/run-pdoc3.py) script.
  This will **fail** unless you run it from an environment where binary refinery has been installed as a Python package.
  To run it, you have to specify the path of a virtual environment as the first command line argument to [run-pdoc3.py](https://github.com/binref/refinery/blob/master/run-pdoc3.py),
  which will cause the script to run itself again using the interpreter of that environment.
  If you are certain that you want to run [run-pdoc3.py](https://github.com/binref/refinery/blob/master/run-pdoc3.py),
  there is a command line switch to force the script to run with the current default Python interpreter.
  The script installs the [pdoc3 package][pdoc3] and uses it to generate an HTML documentation for the `refinery` package.
  The documentation can then be found in the subdirectory `html` directly next to this readme file.
  The [tutorials](https://github.com/binref/refinery/blob/master/tutorials) are Jupyter notebooks which you can simply run and execute if your virtual environment has [Jupyter installed][jupyter].
  It's worth pointing out that [Visual Studio Code has very comfortable support for Jupyter][jupyter-vscode].


  The units [emit][] and [dump][] play a special role:
  The former is for outputting data while the latter is for dumping data to the clipboard or to disk.
  As an example, consider the following pipeline:
  ```
  emit M7EwMzVzBkI3IwNTczM3cyMg2wQA | b64 | zl | hex
  ```
  Here, we emit the string `M7EwMzVzBkI3IwNTczM3cyMg2wQA`,
  base64-decode it using [b64][],
  zlib-decompress the result using [zl][],
  and finally [hex][]-decode the decompressed data.
  Each unit performs the _"decoding"_ operation of a certain transformation by default, but some of them also implement the reverse operation.
  If they do, this is always done by providing the command line switch `-R`, or `--reverse`.
  You can produce the above base64 string using the following command because [hex][], [zl][], and [b64][] all provide the reverse operation:
  ```
  emit "Hello World" | hex -R | zl -R | b64 -R
  ```
  Given a file `packed.bin` containing a base64 encoded payload buffer, the following pipeline extracts said payload to `payload.bin`:
  ```
  emit packed.bin | carve -l -t1 b64 | b64 | dump payload.bin
  ```
  The [carve][] unit can be used to carve blocks of data out of the input buffer,
  in this case it looks for base64 encoded data, sorts them by length (`-l`) and returns the first of these (`-t1`),
  which carves the largest base64-looking chunk of data from `packed.bin`.
  The data is then base64-decoded and dumped to the file `payload.bin`.
  The unit [pack][], will pick all numeric expressions from a text buffer and turn them into their binary representation.
  A simple example is the pipeline
  ```
  emit "0xBA 0xAD 0xC0 0xFF 0xEE" | pack | hex -R
  ```
  which will output the string `BAADC0FFEE`.

  Extract the largest piece of base64 encoded data from a BLOB and decode it:
  ```
  emit file.exe | carve -ds b64
  ```
  Carve a ZIP file from a buffer, pick a DLL from it, and display information about it:
  ```
  emit file.bin | carve-zip | xtzip file.dll | pemeta
  ```
  List PE file sections with their corresponding SHA-256 hash:
  ```
  emit file.exe | vsect [| sha256 -t | cfmt {} {path} ]]
  ```
  Recursively list all files in the current directory with their respective SHA-256 hash:
  ```
  ef "**" [| sha256 -t | cfmt {} {path} ]]
  ```
  Extract indicators from all files recursively enumerated inside the current directory:
  ```
  ef "**" [| xtp -n6 ipv4 socket url email | dedup ]]
  ```
  Convert the hard-coded IP address `0xC0A80C2A` in network byte order to a readable format:
  ```
  emit 0xC0A80C2A | pack -EB4 | pack -R [| sep . ]
  ```
  Perform a single byte XOR brute force and attempt to extract a PE file payload in every iteration:
  ```
  emit file.bin | rep 0x100 [| xor v:index | carve-pe -R | peek | dump {name} ]
  ```

  Extract a RemCos C2 server:
  ```
  emit c0019718c4d4538452affb97c70d16b7af3e4816d059010c277c4e579075c944 \
    | perc SETTINGS [| put keylen cut::1 | rc4 cut::keylen | xtp socket ]
  ```
  Extract an AgentTesla configuration:
  ```
  emit fb47a566911905d37bdb464a08ca66b9078f18f10411ce019e9d5ab747571b40 \
    | dnfields [| aes x::32 --iv x::16 -Q ]] \
    | rex -M "((??email))\n(.*)\n(.*)\n:Zone" addr={1} pass={2} host={3}
  ```
  Extract the PowerShell payload from a malicious XLS macro dropper:
  ```
  emit 81a1fca7a1fb97fe021a1f2cf0bf9011dd2e72a5864aad674f8fea4ef009417b [ \
    | xlxtr 9.5:11.5 15.15 12.5:14.5 [ \
    | scope -n 3 | chop -t 5 [| sorted -a | snip 2: | sep ] \
    | pack 10 | alu --dec -sN B-S ]] \
    | dump payload.ps1
  ```
  And get the domains for the next stage:
  ```
  emit payload.ps1
    | carve -sd b64 | zl | deob-ps1
    | carve -sd b64 | zl | deob-ps1
    | xtp -f domain
  ```
  Extract the configuration of unpacked HawkEye samples:
  ```
  emit ee790d6f09c2292d457cbe92729937e06b3e21eb6b212bf2e32386ba7c2ff22c \
    | put cfg perc[RCDATA]:c:: [\
    | xtp guid | pbkdf2 48 rep[8]:h:00 | cca eat:cfg | aes -Q x::32 --iv x::16 ] \
    | dnds
  ```
  Warzone RAT:
  ```
  emit 4537fab9de768a668ab4e72ae2cce3169b7af2dd36a1723ddab09c04d31d61a5 \
    | vsect .bss | struct I{key:{}}{} [\
    | rc4 eat:key | struct I{host:{}}{port:H} {host:u16}:{port} ]
  ```
  Extract payload from a shellcode loader and carve its c2:
  ```
  emit 58ba30052d249805caae0107a0e2a5a3cb85f3000ba5479fafb7767e2a5a78f3 \
    | rex yara:50607080.* [| struct LL{s:L}{} | xor -B2 accu[s]:@msvc | xtp url ]
  ```
  Get the malicious VBA macros from a forgotten time when this was how it was done:
  ```
  emit ee103f8d64cd8fa884ff6a041db2f7aa403c502f54e26337c606044c2f205394 \
    | xtvba
  ```
  And then extract the malicious downloader payload:
  ```
  emit ee103f8d64cd8fa884ff6a041db2f7aa403c502f54e26337c606044c2f205394 \
    | doctxt | repl drp:c: | carve -s b64 | rev | b64 | rev | ppjscript
  ```
  Extract payload URLs from a malicious PDF document:
  ```
  emit 066aec7b106f669e587b10b3e3c6745f11f1c116f7728002f30c072bd42d6253 \
    | xt JS | csd string | csd string | url | xtp url [| urlfix ]]
  ```
  Extract the payload URL from an equation editor exploit document:
  ```
  emit e850f3849ea82980cf23844ad3caadf73856b2d5b0c4179847d82ce4016e80ee \
    | officecrypt | xt oleObject | xt native | rex Y:E9[] | vstack -a=x32 -w=200 | xtp
  ```

  Assume that `data` is a file which was encrypted with 256-bit AES in CBC mode.
  The key was derived from the secret passphrase `swordfish` using the PBKDF2 key derivation routine using the salt `s4lty`.
  The IV is prefixed to the buffer as the first 16 bytes.
  It can be decrypted with the following pipeline:
  ```
  emit data | aes --mode cbc --iv cut::16 pbkdf2[32,s4lty]:swordfish
  ```
  Here, both `cut:0:16` and `pbkdf2[32,s4lty]:swordfish` are multibin arguments that use a special handler.
  In this case, `cut:0:16` extracts the slice `0:16` (i.e. the first 16 bytes) from the input data - after application of this multibin handler,
  the input data has the first 16 bytes removed and the argument `iv` is set to these exact 16 bytes.
  The final argument specifies the 32 byte encryption key:
  The handler `pbkdf2[32,s4lty]` on the other hand instructs refinery to create an instance of the pbkdf2 unit as if it had been given the command line parameters `32` and `s4lty` in this order and process the byte string `swordfish` with this unit.
  As a simple test, the following pipeline will encrypt and decrypt a sample piece of text:
  ```
  emit "Once upon a time, at the foot of a great mountain ..." ^
      | aes pbkdf2[32,s4lty]:swordfish --iv md5:X -R | ccp md5:X ^
      | aes pbkdf2[32,s4lty]:swordfish --iv cut:0:16
  ```
  [OA]: https://www.youtube.com/c/OALabs
  [JB]: https://bin.re/
  [MH]: https://www.youtube.com/@MalwareAnalysisForHedgehogs
  [CY]: https://www.youtube.com/@jstrosch
  [BLOG]: https://bin.re/blog/analysing-ta551-malspam-with-binary-refinery/
  [VOD1]: https://www.youtube.com/watch?v=4gTaGfFyMK4
  [VOD2]: https://www.youtube.com/watch?v=5ZtmYNmVMKo
  [VOD3]: https://www.youtube.com/live/-B072w0qjNk
  [remnux]: https://hub.docker.com/r/remnux/binary-refinery
  [remnux-main]: https://remnux.org/
  [pdoc3]: https://pdoc3.github.io/pdoc/
  [docs]: https://binref.github.io/
  [argformats]: https://binref.github.io/lib/argformats.html
  [frame]: https://binref.github.io/lib/frame.html
  [meta]: https://binref.github.io/lib/meta.html
  [license]: https://opensource.org/licenses/BSD-3-Clause
  [tests]: https://github.com/binref/refinery/actions
  [codecov]: https://codecov.io/gh/binref/refinery/?branch=master
  [pypi]: https://pypi.org/project/binary-refinery/
  [venv]: https://docs.python.org/3/library/venv.html
  [zsh1]: https://github.com/binref/refinery/discussions/18
  [zsh2]: shells/zsh
  [psh1]: https://github.com/binref/refinery/issues/5
  [fsh1]: https://github.com/binref/refinery/discussions/55
  [fsh2]: https://github.com/binref/refinery/issues/22
  [dump]: https://binref.github.io/#refinery.dump
  [emit]: https://binref.github.io/#refinery.emit
  [stego]: https://binref.github.io/#refinery.stego
  [pcap]: https://binref.github.io/#refinery.pcap
  [hex]: https://binref.github.io/#refinery.hex
  [zl]: https://binref.github.io/#refinery.zl
  [b64]: https://binref.github.io/#refinery.b64
  [carve]: https://binref.github.io/#refinery.carve
  [pack]: https://binref.github.io/#refinery.pack
  [jupyter]: https://jupyter.org/install
  [jupyter-vscode]: https://code.visualstudio.com/docs/datascience/jupyter-notebooks


pkgId: 38b364817ed85ee215b8c688d8ce58cdd648f27201d08907e64d7d5b3560edef
name: python-binary_wheel_builder-help
arch: noarch
version: 3.10.0
epoch: 0
release: 1
summary: Development documents and examples for binary_wheel_builder
url: https://github.com/timo-reymann/python-binary-wheel-builder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-binary_wheel_builder-3.10.0-1.src.rpm
location_href: Packages/python-binary_wheel_builder-help-3.10.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/binary_wheel_builder.svg)](https://pypi.org/project/binary_wheel_builder)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/binary-wheel-builder)](https://pypi.org/project/binary_wheel_builder)
  [![LICENSE](https://img.shields.io/github/license/timo-reymann/python-binary-wheel-builder)](https://github.com/timo-reymann/binary-wheel-builder/blob/main/LICENSE)
  [![CircleCI](https://circleci.com/gh/timo-reymann/python-binary-wheel-builder.svg?style=shield)](https://app.circleci.com/pipelines/github/timo-reymann/python-binary-wheel-builder)
  [![codecov](https://codecov.io/gh/timo-reymann/python-binary-wheel-builder/graph/badge.svg?token=LFBPaleiaO)](https://codecov.io/gh/timo-reymann/python-binary-wheel-builder)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=timo-reymann_python-binary-wheel-builder&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=timo-reymann_python-binary-wheel-builder)
  [![Code Smells](https://sonarcloud.io/api/project_badges/measure?project=timo-reymann_python-binary-wheel-builder&metric=code_smells)](https://sonarcloud.io/summary/new_code?id=timo-reymann_python-binary-wheel-builder)
  [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=timo-reymann_python-binary-wheel-builder&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=timo-reymann_python-binary-wheel-builder)
  [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=timo-reymann_python-binary-wheel-builder&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=timo-reymann_python-binary-wheel-builder)
  [![Renovate](https://img.shields.io/badge/renovate-enabled-green?logo=data:image/svg+xml;base64,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)](https://renovatebot.com)
  <p align="center">
  	<img width="300" src="https://raw.githubusercontent.com/timo-reymann/python-binary-wheel-builder/main/.github/images/logo.png">
      <br />
      Build deterministic python wheels to distribute CLI tools (third party or your own with python and make them easily usable using python code.
  </p>

  - deterministic wheel file output
  - Use with Python Code or as CLI
  - [Prebuilt data sources](https://timo-reymann.github.io/python-binary-wheel-builder/api.wheel_sources.html) for your binaries
  - Ready to release and ship your binaries
  - Wrapper for cli calls inside Python
  - Exposes wheel as module entrypoint (`python -m your_cli`) and adds to path (`your-cli`)

  - Python 3.8+ for host running wheel build
  - For target host every 3.x should work


  ```sh

  pip install binary_wheel_builder[cli]

  pip install binary_wheel_builder
  ```

  ````sh
  pipx install binary_wheel_builder[cli]
  ````


  1. Create your config file e. g. `my-cli-wheel.yaml`:
     ```yaml
     package: my_cli
     executable: my-cli-bin
     name: my-cli
     version: 0.0.1
     summary: My CLI provides nice and clean functionality on the terminal
     description: !FileContent README.md
     license: MIT
     requires_python: ">=3.8"
     classifier:
        - "License :: OSI Approved :: MIT License"
        
     project_urls:
        
        "Homepage": "https://github.com/my-org/my-cli"
        "Source Code": "https://github.com/my-org/my-cli,git"
        "Bug Tracker": "https://github.com/my-org/my-cli/issues"
     source: !WheelSource
       
       implementation: binary_wheel_builder.api.wheel_sources.GithubReleaseBinarySource
       project_slug: my-org/my-cli
       version: "0.0.1"
       tag_prefix: "" # e.g. set to v when your tag is vX.Y.Z
      
       binary_path: my_cli/my-cli-bin
       
       asset_name_mapping:
         !WellknownPlatform MAC_SILICON: "mycli-darwin-arm64"
         !WellknownPlatform MAC_INTEL: "mycli-darwin-amd64"
         !WellknownPlatform LINUX_GENERIC_x86_64: "my-cli-linux-amd64"
         !WellKnownPlatform LINUX_GENERIC_aarch64: "my-cli-linux-arm"
       
       platforms:
         - !WellknownPlatform MAC_INTEL
         - !WellknownPlatform MAC_SILICON
         - !WellknownPlatform LINUX_GENERIC_x86_64
         - !WellKnownPlatform LINUX_GENERIC_aarch64
     ```
  2. Build your wheel for all platforms
     ```shell
     binary-wheel-builder --wheel-spec my-cli-wheel.yaml
     ```
  3. Upload your wheel files using [twine](https://twine.readthedocs.io/en/stable/):
     ```sh
     twine upload -r pypi dist/*
     ```
  4. Enjoy and consume your CLI as a package
  > If you want to have auto complete and validation right in the IDE, you can use the `wheel.schema.json` JSON Schema.
  >
  > [VSCode Guide](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings) | [IntelliJ IDEA IDEs Guide](https://www.jetbrains.com/help/idea/json.html#ws_json_schema_add_custom)

  If you prefer to write Python Code you use almost the same structure:
  ````python
  from pathlib import Path
  from binary_wheel_builder.api import build_wheel, Wheel, well_known_platforms
  from binary_wheel_builder.api.wheel_sources import GithubReleaseBinarySource

  class MyCliGithubReleaseSource(GithubReleaseBinarySource):
      def __init__(self, version: str):
          super().__init__(
              "my-org/my-repo",
              version,
              {
                  well_known_platforms.MAC_SILICON: "mycli-darwin-arm64",
                  well_known_platforms.MAC_INTEL: "mycli-darwin-amd64",
                  well_known_platforms.LINUX_GENERIC_x86_64: "my-cli-linux-amd64",
                  well_known_platforms.LINUX_GENERIC_aarch64: "my-cli-linux-arm",
              },
              "my_cli/my-cli-bin"
          )
  dist_folder = Path("dist")
  print("Built wheels:")
  for result in build_wheel(
          Wheel(
              package="my_cli",
              executable="my-cli-bin",
              name="my-cli",
              version="0.0.1",
              summary='My CLI provides nice and clean functionality on the terminal',
              license='MIT',
              requires_python=">=3.9",
              classifier=[
                  'License :: OSI Approved :: MIT License',
                  
              ],
              project_urls={
                  'Homepage': 'https://github.com/my-org/my-cli',
                  'Source Code': 'https://github.com/my-org/my-cli,git',
                  'Bug Tracker': 'https://github.com/my-org/my-cli/issues',
              },
              source=MyCliGithubReleaseSource("0.0.1"),
              platforms=[
                  well_known_platforms.MAC_INTEL,
                  well_known_platforms.MAC_SILICON,
                  well_known_platforms.LINUX_GENERIC_x86_64,
                  well_known_platforms.LINUX_GENERIC_aarch64
              ]
          ),
          dist_folder
  ):
      print(f" > {result.file_path} [{result.checksum}]")
  ````
  Afterwards upload with twine:
  Upload your wheel files using [twine](https://twine.readthedocs.io/en/stable/):
  ```sh
  twine upload -r pypi dist/*
  ```


  ```sh
  python -m my_cli
  ```

  ````sh
  my-cli
  ````

  ```python
  import subprocess
  from my_cli import exec

  exec.exec_with_templated_output(["--help"])

  exec.create_subprocess(["--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)


  exec.exec_silently(["--version"])
  ```

  Sometimes managing CLI dependencies for tooling etc. can become quite a pain.
  Also sometimes there are just so many options to distribute binaries, but Python is preinstalled on almost any nix
  machine.
  This opens great possibilities with using pip(x) to install dependencies or even reuse standalone CLI applications as
  regular dependency in your code.

  - [Library documentation](https://timo-reymann.github.io/python-binary-wheel-builder/)

  I love your input! I want to make contributing to this project as easy and transparent as possible, whether it's:
  - Reporting a bug
  - Discussing the current state of the configuration
  - Submitting a fix
  - Proposing new features
  - Becoming a maintainer
  To get started please read the [Contribution Guidelines](./CONTRIBUTING.md).


  - Python 3.8+
  - Poetry


  ```sh
  poetry run pytest integration_tests/
  ```

  ```sh
  poetry run pytest binary_wheel_builder/
  ```

  ````sh
  poetry install
  ````

  - Using platform native package management
  - curl'ing dependencies


pkgId: 1808f0967eb43fdf0f6b37c84fa67bf72dcb256c3264f821eb9e7ba757111fe1
name: python-bio-compose-help
arch: noarch
version: 0.8.3
epoch: 0
release: 1
summary: Development documents and examples for bio-compose
url: https://pypi.org/project/bio-compose/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bio-compose-0.8.3-1.src.rpm
location_href: Packages/python-bio-compose-help-0.8.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1bVtTmbMLnfFBv44rPwmBFsHvpX7woDWn?usp=sharing)
  ![Deployment Pipeline](https://github.com/biosimulators/bio-compose/actions/workflows/pipeline.yml/badge.svg)
  [![Documentation](https://readthedocs.org/projects/bio-compose/badge/?version=latest)](https://bio-compose.readthedocs.io/en/latest/)






  The complete `BioCompose` documentation can be found here: https://bio-compose.readthedocs.io/en/latest/





  The primary method of user-facing interaction for this service is done through the use of a high-level "notebook" api called `bio_check`.
  A convenient notebook demonstrating the functionality of this service is hosted on Google Colab and can be accessed by clicking the above "Open In Colab" badge.

  Installation of this tooling can be performed using PyPI as such:

  ```bash
  pip install bio-compose
  ```





  A convienient template notebook for converting the outputs of Smoldyn simulations to Simularium trajectories can be
  [found here.](https://colab.research.google.com/drive/17uMMRq3L3KqRIXnezahM6TtOtJYK8Cu6#scrollTo=6n5Wf58hthFm)


pkgId: 5628dc2a153abe02d62c057e5c6372e1400a8ff0670de18cbeaa994bad99be3f
name: python-bio-compose-help
arch: noarch
version: 0.8.7
epoch: 0
release: 1
summary: Development documents and examples for bio-compose
url: https://pypi.org/project/bio-compose/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bio-compose-0.8.7-1.src.rpm
location_href: Packages/python-bio-compose-help-0.8.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1bVtTmbMLnfFBv44rPwmBFsHvpX7woDWn?usp=sharing)
  ![Deployment Pipeline](https://github.com/biosimulators/bio-compose/actions/workflows/pipeline.yml/badge.svg)
  [![Documentation](https://readthedocs.org/projects/bio-compose/badge/?version=latest)](https://bio-compose.readthedocs.io/en/latest/)






  The complete `BioCompose` documentation can be found here: https://bio-compose.readthedocs.io/en/latest/





  The primary method of user-facing interaction for this service is done through the use of a high-level "notebook" api called `bio_check`.
  A convenient notebook demonstrating the functionality of this service is hosted on Google Colab and can be accessed by clicking the above "Open In Colab" badge.

  Installation of this tooling can be performed using PyPI as such:

  ```bash
  pip install bio-compose
  ```





  A convienient template notebook for converting the outputs of Smoldyn simulations to Simularium trajectories can be
  [found here.](https://colab.research.google.com/drive/17uMMRq3L3KqRIXnezahM6TtOtJYK8Cu6#scrollTo=6n5Wf58hthFm)



  Poetry is used as the environment manager. Poetry uses a globally referenced configuration whose cache setup may lead to permission errors when running `poetry install`. In the event that such errors exist, run the following:
  ```bash
  poetry config cache-dir ~/poetry-cache
  mkdir -p ~/poetry-cache
  chmod -R u+w ~/poetry-cache


  poetry install
  ```


pkgId: a6f6a2c2bbf9f9f52382a95c72cba44cbab4bbc412a5f0ad099bc35eb05e0247
name: python-bioRAT-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for bioRAT
url: https://github.com/biocpy/bioRAT
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bioRAT-0.2.0-1.src.rpm
location_href: Packages/python-bioRAT-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Built Status](https://api.cirrus-ci.com/github/<USER>/bioRAT.svg?branch=main)](https://cirrus-ci.com/github/<USER>/bioRAT)
  [![ReadTheDocs](https://readthedocs.org/projects/bioRAT/badge/?version=latest)](https://bioRAT.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/bioRAT/main.svg)](https://coveralls.io/r/<USER>/bioRAT)
  [![PyPI-Server](https://img.shields.io/pypi/v/bioRAT.svg)](https://pypi.org/project/bioRAT/)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/bioRAT.svg)](https://anaconda.org/conda-forge/bioRAT)
  [![Monthly Downloads](https://pepy.tech/badge/bioRAT/month)](https://pepy.tech/project/bioRAT)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/bioRAT)
  -->

  [![PyPI-Server](https://img.shields.io/pypi/v/bioRAT.svg)](https://pypi.org/project/biorat/)
  ![Unit tests](https://github.com/BiocPy/bioRAT/actions/workflows/pypi-test.yml/badge.svg)



  Just a collection of useful data processing functions.

  <!-- pyscaffold-notes -->



  This project has been set up using PyScaffold 4.6. For details and usage
  information on PyScaffold see https://pyscaffold.org/.


pkgId: 206917efd6c6c40eaa98260f853a9a824f7952361c50c1fb8cd5afb0da5ef42b
name: python-bioat-help
arch: noarch
version: 0.13.5
epoch: 0
release: 1
summary: Development documents and examples for bioat
url: https://github.com/hermanzhaozzzz/bioat
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bioat-0.13.5-1.src.rpm
location_href: Packages/python-bioat-help-0.13.5-1.noarch.rpm
checksum_type: sha256
description:
  the Bioinformatic Analysis Tools

  Bref:  <u>**bioat**, a python **package** & **command line toolkit** for Bioinformatics and data science!</u>

  Home: https://github.com/hermanzhaozzzz/bioat

  License: Apache-2.0

  | Name | Downloads | Version | Platforms | Test |
  | --- | --- | --- | --- | --- |
  |[![Conda Recipe](https://img.shields.io/badge/recipe-bioat-green.svg)](https://anaconda.org/conda-forge/bioat) | [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/bioat.svg)](https://anaconda.org/conda-forge/bioat) | [![Conda Version](https://img.shields.io/conda/vn/conda-forge/bioat.svg)](https://anaconda.org/conda-forge/bioat) | [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/bioat.svg)](https://anaconda.org/conda-forge/bioat) | [![Azure Pipelines](https://dev.azure.com/conda-forge/feedstock-builds/_apis/build/status/bioat-feedstock?branchName=main)](https://dev.azure.com/conda-forge/feedstock-builds/_build/latest?definitionId=23719&branchName=main) |


  Name: [赵华男 | Huanan Herman Zhao](https://scholar.google.com/citations?user=ojSVoWQAAAAJ&hl=en) |  EMail: hermanzhaozzzz AT gmail.com | [Zhihu](https://www.zhihu.com/people/hymanzhaozzzz) | [BLOG](http://zhaohuanan.cc)


  ```shell

  pip install --upgrade bioat

  conda install -c conda-forge bioat
  ```


  ```shell

  bioat list

  bioat version

  bioat about


  bioat bam remove_clip --help
  samtools view -h test_sorted_n.bam | bioat bam remove_clip | tail
  ```
  [circos plot](docs/demo_circos-plot.ipynb)



  See [Doc](https://bioat.readthedocs.io/en/latest/)


pkgId: c42c2fe0a263729d6924c0ffbf0fd3527051c21cfa5ff0a640a2b752ce683456
name: python-biobb-mem-help
arch: noarch
version: 5.0.4
epoch: 0
release: 1
summary: Development documents and examples for biobb-mem
url: https://github.com/bioexcel/biobb_mem
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-biobb-mem-5.0.4-1.src.rpm
location_href: Packages/python-biobb-mem-help-5.0.4-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/github/v/tag/bioexcel/biobb_mem?label=Version)](https://GitHub.com/bioexcel/biobb_mem/tags/)
  [![](https://img.shields.io/pypi/v/biobb-mem.svg?label=Pypi)](https://pypi.python.org/pypi/biobb-mem/)
  [![](https://img.shields.io/conda/vn/bioconda/biobb_mem?label=Conda)](https://anaconda.org/bioconda/biobb_mem)
  [![](https://img.shields.io/conda/dn/bioconda/biobb_mem?label=Conda%20Downloads)](https://anaconda.org/bioconda/biobb_mem)
  [![](https://img.shields.io/badge/Docker-Quay.io-blue)](https://quay.io/repository/biocontainers/biobb_mem?tab=tags)
  [![](https://img.shields.io/badge/Singularity-GalaxyProject-blue)](https://depot.galaxyproject.org/singularity/biobb_mem:5.0.4--pyhdfd78af_0)

  [![](https://img.shields.io/badge/OS-Unix%20%7C%20MacOS-blue)](https://github.com/bioexcel/biobb_mem)
  [![](https://img.shields.io/pypi/pyversions/biobb-mem.svg?label=Python%20Versions)](https://pypi.org/project/biobb-mem/)
  [![](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![](https://img.shields.io/badge/Open%20Source%3f-Yes!-blue)](https://github.com/bioexcel/biobb_mem)

  [![](https://readthedocs.org/projects/biobb-mem/badge/?version=latest&label=Docs)](https://biobb-mem.readthedocs.io/en/latest/?badge=latest)
  [![](https://img.shields.io/website?down_message=Offline&label=Biobb%20Website&up_message=Online&url=https%3A%2F%2Fmmb.irbbarcelona.org%2Fbiobb%2F)](https://mmb.irbbarcelona.org/biobb/)
  [![](https://img.shields.io/badge/Youtube-tutorials-blue?logo=youtube&logoColor=red)](https://www.youtube.com/@BioExcelCoE/search?query=biobb)
  [![](https://zenodo.org/badge/DOI/10.1038/s41597-019-0177-4.svg)](https://doi.org/10.1038/s41597-019-0177-4)
  [![](https://img.shields.io/endpoint?color=brightgreen&url=https%3A%2F%2Fapi.juleskreuer.eu%2Fcitation-badge.php%3Fshield%26doi%3D10.1038%2Fs41597-019-0177-4)](https://www.nature.com/articles/s41597-019-0177-4#citeas)

  [![](https://docs.bioexcel.eu/biobb_mem/junit/testsbadge.svg)](https://docs.bioexcel.eu/biobb_mem/junit/report.html)
  [![](https://docs.bioexcel.eu/biobb_mem/coverage/coveragebadge.svg)](https://docs.bioexcel.eu/biobb_mem/coverage/)
  [![](https://docs.bioexcel.eu/biobb_mem/flake8/flake8badge.svg)](https://docs.bioexcel.eu/biobb_mem/flake8/)
  [![](https://img.shields.io/github/last-commit/bioexcel/biobb_mem?label=Last%20Commit)](https://github.com/bioexcel/biobb_mem/commits/master)
  [![](https://img.shields.io/github/issues/bioexcel/biobb_mem.svg?color=brightgreen&label=Issues)](https://GitHub.com/bioexcel/biobb_mem/issues/)

  [![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green)](https://fair-software.eu)
  [![](https://www.bestpractices.dev/projects/8847/badge)](https://www.bestpractices.dev/projects/8847)

  [](https://bestpractices.coreinfrastructure.org/projects/8847/badge)

  [//]: # (The previous line invisible link is for compatibility with the howfairis script https://github.com/fair-software/howfairis-github-action/tree/main wich uses the old bestpractices URL)




  biobb_mem is a BioBB category for membrane analysis and manipulation.
  biobb_mem allows analysis of membrane properties and manipulation of membrane systems using tools like [MDAnalysis](https://github.com/MDAnalysis/mdanalysis), [FATSLiM](https://github.com/FATSLiM/fatslim) and [LiPyphilic](https://github.com/p-j-smith/lipyphilic).
  Biobb (BioExcel building blocks) packages are Python building blocks that
  create new layer of compatibility and interoperability over popular
  bioinformatics tools.
  The latest documentation of this package can be found in our readthedocs site:
  [latest API documentation](http://biobb-mem.readthedocs.io/en/latest/).


  v5.0.4 2024.2


  Using PIP:

  > **Important:** PIP only installs the package. All the dependencies must be installed separately. To perform a complete installation, please use ANACONDA or DOCKER.

  * Installation:


          pip install "biobb_mem>=5.0.4"


  * Usage: [Python API documentation](https://biobb-mem.readthedocs.io/en/latest/modules.html)

  Using ANACONDA:

  * Installation:


          conda install -c bioconda "biobb_mem>=5.0.4"


  * Usage: With conda installation BioBBs can be used with the [Python API documentation](https://biobb-mem.readthedocs.io/en/latest/modules.html) and the [Command Line documentation](https://biobb-mem.readthedocs.io/en/latest/command_line.html)

  Using DOCKER:

  * Installation:


          docker pull quay.io/biocontainers/biobb_mem:5.0.4--pyhdfd78af_0


  * Usage:


          docker run quay.io/biocontainers/biobb_mem:5.0.4--pyhdfd78af_0


  Using SINGULARITY:

  **MacOS users**: it's strongly recommended to avoid Singularity and use **Docker** as containerization system.

  * Installation:


          singularity pull --name biobb_mem.sif https://depot.galaxyproject.org/singularity/biobb_mem:5.0.4--pyhdfd78af_0


  * Usage:


          singularity exec biobb_mem.sif <command>


  The command list and specification can be found at the [Command Line documentation](https://biobb-mem.readthedocs.io/en/latest/command_line.html).


  This software has been developed in the [MMB group](http://mmb.irbbarcelona.org) at the [BSC](http://www.bsc.es/) & [IRB](https://www.irbbarcelona.org/) for the [European BioExcel](http://bioexcel.eu/), funded by the European Commission (EU H2020 [823830](http://cordis.europa.eu/projects/823830), EU H2020 [675728](http://cordis.europa.eu/projects/675728)).

  * (c) 2015-2024 [Barcelona Supercomputing Center](https://www.bsc.es/)
  * (c) 2015-2024 [Institute for Research in Biomedicine](https://www.irbbarcelona.org/)

  Licensed under the
  [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0), see the file LICENSE for details.

  ![](https://bioexcel.eu/wp-content/uploads/2019/04/Bioexcell_logo_1080px_transp.png "Bioexcel")


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

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

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

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

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

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



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

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

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







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

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






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

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



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

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

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






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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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


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

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

  ```

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

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

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

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


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


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

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

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


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

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

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

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



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

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

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

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

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

  For example
  ```

  cellpose_job_gres=gpu:1g.10gb:1

  cellpose_job_mem=15GB
  ```

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


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

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

  You can change this timeout value:

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

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




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




  cellpose=cellpose

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

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


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

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

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

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


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

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

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


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


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


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

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

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

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

          

          
          ...

          
          ...

          
          ...
  ```

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

  ```

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


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


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

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


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


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

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

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




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

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


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

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

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

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



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

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

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

  These are the steps required:

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




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


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

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

  ```ini









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

  [MODELS]








  cellpose=cellpose

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

  cellpose_job=jobs/cellpose.sh
  ```

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

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


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

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

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

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

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

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



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

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

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

  ```ini




  cellpose=cellpose

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

  cellpose_job=jobs/cellpose.sh




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

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

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

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

  ```ini




  cellpose=cellpose

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

  cellpose_job=jobs/cellpose.sh




  cellpose_job_time=00:30:00
  ```

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



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

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

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


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

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

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

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


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

  ```
  import logging

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

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

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

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


pkgId: 4f519954c47b4c991725b01ec531e25948a013f057145c6d2282f14c84237e8d
name: python-biomodules-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for biomodules
url: https://github.com/lawley0316/biomodules
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-biomodules-1.1.0-1.src.rpm
location_href: Packages/python-biomodules-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  1. `MergeDir`，给定一个输入文件夹和一个输出文件，把该文件夹下的所有文件合并到该文件中。



  1. `Fastq2Fasta`，fastq转fasta。



  1. `Fastqc`，使用fastqc进行质量控制。
  2. `Filtlong`，使用Filtlong过滤reads。



  1. `blastn`，使用blastn进行序列比对。


pkgId: 5a6baec4f13a5e19a5c700e37a27b3fd456bb7c3f1673fd7df943c83f9ae58f6
name: python-biomodules-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for biomodules
url: https://github.com/lawley0316/biomodules
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-biomodules-1.1.3-1.src.rpm
location_href: Packages/python-biomodules-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  1. `MergeDir`，给定一个输入文件夹和一个输出文件，把该文件夹下的所有文件合并到该文件中；



  1. `Fastq2Fasta`，fastq转fasta；



  1. `Fastqc`，使用fastqc进行质量控制；
  2. `Filtlong`，使用Filtlong过滤reads；



  1. `blastn`，使用blastn进行序列比对；
  2. `minimap2`，使用minimap2进行序列比对；
  3. `samtools`，使用samtools处理比对结果；


pkgId: 3bcd12f42c1115a2c332f6c981629f006eaa962e34a266386a829e03265b178c
name: python-bioregistry-help
arch: noarch
version: 0.11.28
epoch: 0
release: 1
summary: Development documents and examples for bioregistry
url: https://github.com/biopragmatics/bioregistry
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bioregistry-0.11.28-1.src.rpm
location_href: Packages/python-bioregistry-help-0.11.28-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/biopragmatics/bioregistry/raw/main/docs/source/logo.png" height="150">
  </p>

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

  <p align="center">
      <a href="https://github.com/biopragmatics/bioregistry/actions?query=workflow%3ATests">
          <img alt="Tests" src="https://github.com/biopragmatics/bioregistry/workflows/Tests/badge.svg" />
      </a>
      <a href="https://pypi.org/project/bioregistry">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/bioregistry" />
      </a>
      <a href="https://pypi.org/project/bioregistry">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/bioregistry" />
      </a>
      <a href="https://github.com/biopragmatics/bioregistry/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/bioregistry" />
      </a>
      <a href='https://bioregistry.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/bioregistry/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="https://zenodo.org/badge/latestdoi/319481281">
          <img src="https://zenodo.org/badge/319481281.svg" alt="DOI">
      </a>
      <a href="https://github.com/psf/black">
          <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
      </a>
      <a href="https://github.com/biopragmatics/bioregistry/blob/main/.github/CODE_OF_CONDUCT.md">
          <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" />
      </a>
  </p>

  <p align="center">
     A community-driven integrative meta-registry of life science databases, ontologies, and other resources.
     <br />More information <a href="https://bioregistry.io/summary">here</a>.
  </p>

  The Bioregistry can be accessed, searched, and queried through its associated
  website at https://bioregistry.io.



  The underlying data of the Bioregistry can be downloaded (or edited) directly
  from
  [here](https://github.com/biopragmatics/bioregistry/blob/main/src/bioregistry/data/).
  Several exports to YAML, TSV, and RDF, including consensus views over the
  registry, are built on a weekly basis and can be downloaded via the
  [`exports/`](https://github.com/biopragmatics/bioregistry/tree/main/exports)
  directory.

  The manually curated portions of these data are available under the
  [CC0 1.0 Universal License](https://creativecommons.org/publicdomain/zero/1.0/).
  Aggregated data are redistributed under their original licenses.



  Contributions are both welcomed and encouraged. Contribution guidelines for new
  prefix requests, record edits, record removals, and code updates are available
  in [CONTRIBUTING.md](docs/CONTRIBUTING.md).

  The most simple contribution is to submit an issue:

  - Submit a new prefix using the
    [issue template](https://github.com/biopragmatics/bioregistry/issues/new?assignees=cthoyt&labels=New%2CPrefix&template=new-prefix.yml&title=Add+prefix+%5BX%5D).
    A new pull request will be generated automatically for you.
  - Update an existing record using one of the
    [existing issue templates](https://github.com/biopragmatics/bioregistry/issues/new/choose)
    (e.g., for updating a record's regular expression, merging two prefixes).
  - For any updates that don't have a corresponding template, feel free to start
    with a [blank issue](https://github.com/biopragmatics/bioregistry/issues/new).

  If you want to make a direct contribution, feel free to make edits directly to
  the
  [bioregistry.json](https://github.com/biopragmatics/bioregistry/blob/main/src/bioregistry/data/bioregistry.json)
  file either through the GitHub interface or locally by
  [forking the repository](https://github.com/biopragmatics/bioregistry/blob/main/docs/CONTRIBUTING.md#code-contribution).

  If you want to make a contribution but don't know where to start, you can check
  [this list](https://biopragmatics.github.io/bioregistry/curation/) of curation
  To-Do's that's automatically generated weekly, including more detailed
  information on how to contribute.



  The Bioregistry is maintained by a Review Team and Core Development team whose
  memberships and duties are described in the
  [Project Governance](docs/GOVERNANCE.md).





  The Bioregistry runs some automated tests weekly to check that various metadata
  haven't gone stale. For example, it checks that the homepages are still
  available and that each provider URL is still able to resolve.

  It has a dedicated
  [dashboard](https://biopragmatics.github.io/bioregistry/health) that is not part
  of the main Bioregistry site.



  The database is automatically updated daily thanks to scheduled workflows in
  GitHub Actions. The workflow's configuration can be found
  [here](https://github.com/biopragmatics/bioregistry/blob/main/.github/workflows/update.yml)
  and the last run can be seen
  [here](https://github.com/biopragmatics/bioregistry/actions?query=workflow%3A%22Update+Data%22).
  Further, a
  [changelog](https://github.com/biopragmatics/bioregistry/commits?author=actions-user)
  can be recapitulated from the commits of the GitHub Actions bot.

  If you want to manually update the database, run the following:

  ```shell
  $ tox -e update
  ```

  Make sure that you have valid environment variables or `pystow` configurations
  for `BIOPORTAL_API_KEY`, `ECOPORTAL_API_KEY`, `AGROPORTAL_API_KEY`,
  `FAIRSHARING_LOGIN`, and `FAIRSHARING_PASSWORD`.



  The Bioregistry can be installed from
  [PyPI](https://pypi.org/project/bioregistry/) with:

  ```shell
  $ pip install bioregistry
  ```

  It can be installed in development mode for local curation with:

  ```shell
  $ git clone https://github.com/biopragmatics/bioregistry.git
  $ cd bioregistry
  $ pip install --editable .
  ```

  Build the docs locally with `tox -e docs` then view by opening
  `docs/build/html/index.html`.





  The Bioregistry can be used to normalize prefixes across MIRIAM and all the
  (very plentiful) variants that pop up in ontologies in OBO Foundry and the OLS
  with the `normalize_prefix()` function.

  ```python
  from bioregistry import normalize_prefix


  assert 'ncbitaxon' == normalize_prefix('ncbitaxon')


  assert 'chebi' == normalize_prefix("CHEBI")


  assert 'fbbt' == normalize_prefix("FBbt")


  assert 'ncbitaxon' == normalize_prefix('taxonomy')


  assert 'pubchem.compound' == normalize_prefix('pubchem')


  assert 'eccode' == normalize_prefix('ec-code')
  assert 'eccode' == normalize_prefix('EC_CODE')


  assert normalize_prefix('not a real key') is None
  ```



  The Bioregistry supports parsing a CURIE into a pair of normalized prefix and
  identifier using the `parse_curie()` function:

  ```python
  from bioregistry import parse_curie


  assert ('chebi', '1234') == parse_curie('chebi:1234')


  assert ('fbbt', '00007294') == parse_curie('FBbt:00007294')


  assert ('pubchem.compound', '1234') == parse_curie('pubchem:1234')


  assert ('go', '1234') == parse_curie('GO:GO:1234')
  ```

  This will also apply the same normalization rules for prefixes from the previous
  section on normalizing prefixes for the remaining examples.



  The Bioregistry supports converting a CURIE to a canonical CURIE by normalizing
  the prefix and removing redundant namespaces embedded in LUIs with the
  `normalize_curie()` function.

  ```python
  from bioregistry import normalize_curie


  assert 'chebi:1234' == normalize_curie('chebi:1234')


  assert 'pubchem.compound:1234' == normalize_curie('pubchem:1234')


  assert 'fbbt:1234' == normalize_curie('FBbt:1234')


  assert 'go:1234' == normalize_curie('GO:GO:1234')
  ```



  The Bioregistry can be used to parse CURIEs from IRIs due to its vast registry
  of provider URL strings and additional programmatic logic implemented with
  Python. It can parse OBO Library PURLs, IRIs from the OLS and identifiers.org,
  IRIs from the Bioregistry website, and any other IRIs from well-formed providers
  registered in the Bioregistry. The `parse_iri()` function gets a pre-parsed
  CURIE, while the `curie_from_iri()` function makes a canonical CURIE from the
  pre-parsed CURIE.

  ```python
  from bioregistry import curie_from_iri, parse_iri


  assert ('chebi', '24867') == parse_iri('https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867')
  assert 'chebi:24867' == curie_from_iri('https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867')


  assert ('chebi', '24867') == parse_iri('http://purl.obolibrary.org/obo/CHEBI_24867')
  assert 'chebi:24867' == curie_from_iri('http://purl.obolibrary.org/obo/CHEBI_24867')


  assert ('chebi', '24867') == parse_iri('https://www.ebi.ac.uk/ols/ontologies/chebi/terms?iri=http://purl.obolibrary.org/obo/CHEBI_24867')
  assert 'chebi:24867' == curie_from_iri('https://www.ebi.ac.uk/ols/ontologies/chebi/terms?iri=http://purl.obolibrary.org/obo/CHEBI_24867')


  assert ('chebi', '24867') == parse_iri('https://identifiers.org/CHEBI:24867')
  assert ('chebi', '24867') == parse_iri('http://identifiers.org/CHEBI:24867')
  assert ('chebi', '24867') == parse_iri('https://identifiers.org/CHEBI/24867')
  assert ('chebi', '24867') == parse_iri('http://identifiers.org/CHEBI/24867')


  assert ('chebi', '24867') == parse_iri('https://bioregistry.io/chebi:24867')
  ```

  In general, the Bioregistry knows how to parse both the http and https variants
  of any given URI:

  ```python
  from bioregistry import parse_iri

  assert ('neuronames', '268') == parse_iri("http://braininfo.rprc.washington.edu/centraldirectory.aspx?ID=268")
  assert ('neuronames', '268') == parse_iri("https://braininfo.rprc.washington.edu/centraldirectory.aspx?ID=268")
  ```



  You can generate an IRI from either a CURIE or a pre-parsed CURIE (i.e., a
  2-tuple of a prefix and identifier) with the `get_iri()` function. By default,
  it uses the following priorities:

  1. Custom prefix map (`custom`)
  2. First-party IRI (`default`)
  3. Identifiers.org / MIRIAM (`miriam`)
  4. Ontology Lookup Service (`ols`)
  5. OBO PURL (`obofoundry`)
  6. Name-to-Thing (`n2t`)
  7. BioPortal (`bioportal`)

  ```python
  from bioregistry import get_iri

  assert get_iri("chebi", "24867") == 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867'
  assert get_iri("chebi:24867") == 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867'
  ```

  It's possible to change the default priority list by passing an alternate
  sequence of metaprefixes to the `priority` keyword (see above). For example, if
  you're working with OBO ontologies, you might want to make OBO PURLs the highest
  priority and when OBO PURLs can't be generated, default to something else:

  ```python
  from bioregistry import get_iri

  priority = ["obofoundry", "default", "miriam", "ols", "n2t", "bioportal"]
  assert get_iri("chebi:24867", priority=priority) == 'http://purl.obolibrary.org/obo/CHEBI_24867'
  assert get_iri("hgnc:1234", priority=priority) == 'https://bioregistry.io/hgnc:1234'
  ```

  Even deeper, you can add (or override) any of the Bioregistry's default prefix
  map with the `prefix_map` keyword:

  ```python
  from bioregistry import get_iri

  prefix_map = {
     "myprefix": "https://example.org/myprefix/",
     "chebi": "https://example.org/chebi/",
  }
  assert get_iri("chebi:24867", prefix_map=prefix_map) == 'https://example.org/chebi/24867'
  assert get_iri("myprefix:1234", prefix_map=prefix_map) == 'https://example.org/myprefix/1234'
  ```

  A custom prefix map can be supplied in combination with a priority list, using
  the `"custom"` key for changing the priority of the custom prefix map.

  ```python
  from bioregistry import get_iri

  prefix_map = {"lipidmaps": "https://example.org/lipidmaps/"}
  priority = ["obofoundry", "custom", "default", "bioregistry"]
  assert get_iri("chebi:24867", prefix_map=prefix_map, priority=priority) == \
      'http://purl.obolibrary.org/obo/CHEBI_24867'
  assert get_iri("lipidmaps:1234", prefix_map=prefix_map, priority=priority) == \
      'https://example.org/lipidmaps/1234'
  ```

  Alternatively, there are direct functions for generating IRIs for different
  registries:

  ```python
  import bioregistry as br


  assert br.get_bioregistry_iri('chebi', '24867') == 'https://bioregistry.io/chebi:24867'


  assert br.get_default_iri('chebi', '24867') == 'https://www.ebi.ac.uk/chebi/searchId.do?chebiId=CHEBI:24867'


  assert br.get_obofoundry_iri('chebi', '24867') == 'http://purl.obolibrary.org/obo/CHEBI_24867'


  assert br.get_ols_iri('chebi', '24867') ==
         'https://www.ebi.ac.uk/ols/ontologies/chebi/terms?iri=http://purl.obolibrary.org/obo/CHEBI_24867'


  assert br.get_bioportal_iri('chebi', '24867') == \
      'https://bioportal.bioontology.org/ontologies/CHEBI/?p=classes&conceptid=http://purl.obolibrary.org/obo/CHEBI_24867'


  assert br.get_identifiers_org_iri('chebi', '24867') == 'https://identifiers.org/CHEBI:24867'


  assert br.get_n2t_iri('chebi', '24867') == 'https://n2t.net/chebi:24867'
  ```

  Each of these functions could also return `None` if there isn't a provider
  available or if the prefix can't be mapped to the various resources.



  The Bioregistry can be used to generate prefix maps with various flavors
  depending on your context. Prioritization works the same way as when generating
  IRIs.

  ```python
  from bioregistry import get_prefix_map


  prefix_map = get_prefix_map()


  priority = ["obofoundry", "default", "miriam", "ols", "n2t", "bioportal"]
  prefix_map = get_prefix_map(uri_prefix_priority=priority)


  remapping = {"chebi": "CHEBI"}
  prefix_map = get_prefix_map(remapping=remapping)
  ```



  The pattern for an entry in the Bioregistry can be looked up quickly with
  `get_pattern()` if it exists. It prefers the custom curated, then MIRIAM, then
  Wikidata pattern.

  ```python
  import bioregistry

  assert '^GO:\\d{7}$' == bioregistry.get_pattern('go')
  ```

  Entries in the Bioregistry can be checked for deprecation with the
  `is_deprecated()` function. MIRIAM and OBO Foundry don't often agree - OBO
  Foundry takes precedence since it seems to be updated more often.

  ```python
  import bioregistry

  assert bioregistry.is_deprecated('nmr')
  assert not bioregistry.is_deprecated('efo')
  ```

  Entries in the Bioregistry can be looked up with the `get_resource()` function.

  ```python
  import bioregistry

  entry = bioregistry.get_resource('taxonomy')

  ```

  The full Bioregistry can be read in a Python project using:

  ```python
  import bioregistry

  registry = bioregistry.read_registry()
  ```



  After installation with the `[web]` extras, the Bioregistry web application can
  be run with the following code:

  ```shell
  $ python -m pip install bioregistry[web]
  $ bioregistry web
  ```

  to run a web app that functions like Identifiers.org, but backed by the
  Bioregistry. A public instance of this app is hosted by the
  [Gyori Lab for Computational Biomedicine](https://gyorilab.github.io) at
  https://bioregistry.io.





  The code in this repository is licensed under the
  [MIT License](https://github.com/biopragmatics/bioregistry/blob/main/LICENSE).



  If you use the Bioregistry in your code, support us by including our badge in
  your project's README.md:

  ```markdown
  [![Powered by the Bioregistry](https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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)](https://github.com/biopragmatics/bioregistry)
  ```

  If your README uses reStructuredText (.rst), use this instead:

  ```
  .. image:: https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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
      :target: https://github.com/biopragmatics/bioregistry
      :alt: Powered by the Bioregistry
  ```

  It looks like this:
  [![Powered by the Bioregistry](https://img.shields.io/static/v1?label=Powered%20by&message=Bioregistry&color=BA274A&style=flat&logo=image/png;base64,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)](https://github.com/biopragmatics/bioregistry)



  > [Unifying the identification of biomedical entities with the Bioregistry](https://bioregistry.io/doi:10.1038/s41597-022-01807-3) >
  > <br />Hoyt, C. T., Balk, M., Callahan, T. J., Domingo-Fernandez, D., Haendel,
  > M. A., Hegde, H. B., Himmelstein, D. S., Karis, K., Kunze, J., Lubiana, T.,
  > Matentzoglu, N., McMurry, J., Moxon, S., Mungall, C. J., Rutz, A., Unni, D.
  > R., Willighagen, E., Winston, D., and Gyori, B. M. (2022) <br />_Nature
  > Scientific Data_, s41597-022-01807-3

  ```bibtex
  @article{Hoyt2022Bioregistry,
      author = {Hoyt, Charles Tapley and Balk, Meghan and Callahan, Tiffany J and Domingo-Fern{\'{a}}ndez, Daniel and Haendel, Melissa A and Hegde, Harshad B and Himmelstein, Daniel S and Karis, Klas and Kunze, John and Lubiana, Tiago and Matentzoglu, Nicolas and McMurry, Julie and Moxon, Sierra and Mungall, Christopher J and Rutz, Adriano and Unni, Deepak R and Willighagen, Egon and Winston, Donald and Gyori, Benjamin M},
      doi = {10.1038/s41597-022-01807-3},
      issn = {2052-4463},
      journal = {Sci. Data},
      number = {1},
      pages = {714},
      title = {{Unifying the identification of biomedical entities with the Bioregistry}},
      url = {https://doi.org/10.1038/s41597-022-01807-3},
      volume = {9},
      year = {2022}
  }
  ```

  Talks on the Bioregistry:

  - [Future Curation in the Bioregistry](https://bit.ly/wpci2022-bioregistry-maintenance)
    (WPCI, December 2022)
  - [The Bioregistry - Governance and Review Team](https://bit.ly/wpci2022-bioregistry-governance)
    (WPCI, December 2022)
  - [Development, Maintenance, and Expansion of the Bioregistry](https://bit.ly/sorger-lab-bioregistry-2022)
    (Sorger Lab Meeting, October 2022)
  - [The Bioregistry, CURIEs, and OBO Community Health](https://bit.ly/icbo2022-cth)
    (ICBO 2022 (September))
  - [Introduction to the Bioregistry](https://bit.ly/bioregistry-short-talk)
    (Sorger Lab Meeting, July 2021)



  The Bioregistry was primarily developed by the
  [Gyori Lab for Computational Biomedicine](https://gyorilab.github.io) at
  Northeastern University, which was previously a part of the
  [Laboratory of Systems Pharmacology](https://hits.harvard.edu/the-program/laboratory-of-systems-pharmacology/about/)
  in the [Harvard Program in Therapeutic Science (HiTS)](https://hits.harvard.edu)
  at [Harvard Medical School](https://hms.harvard.edu/).



  1. Chan Zuckerberg Initiative (CZI) 2023-329850
  2. DARPA Automating Scientific Knowledge Extraction and Modeling (ASKEM)
     HR00112220036
  3. DARPA Young Faculty Award W911NF2010255 (PI: Benjamin M. Gyori).

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


pkgId: 85696026841c55d143cc3ca7b1ff17741a6df7d7753370da51bb5afb71d0dbbc
name: python-bioversions-help
arch: noarch
version: 0.6.12
epoch: 0
release: 1
summary: Development documents and examples for bioversions
url: https://github.com/biopragmatics/bioversions
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bioversions-0.6.12-1.src.rpm
location_href: Packages/python-bioversions-help-0.6.12-1.noarch.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: a776eccc9f49adcb761a9fbad7c22ed4cf828f9f8ee3a4aa472847fb4f56d3df
name: python-birder-help
arch: noarch
version: 0.0.5a78
epoch: 0
release: 1
summary: Development documents and examples for birder
url: https://gitlab.com/birder/birder
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-birder-0.0.5a78-1.src.rpm
location_href: Packages/python-birder-help-0.0.5a78-1.noarch.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.


