# packages

pkgId: 66fa7d96a8099ff234cade6b4b13e12ee4f91c7b84f704ece26a26a88c198ec3
name: python-bocl
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: B-OCL
url: https://pypi.org/project/bocl/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bocl-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **B-OCL** is a tool designed to parse and evaluate the OCL constraints designed on **BESSER** models.
  It is a python based implementation, that utilises parser and listener generated with the ANTLR4 grammer.

  **BESSER** is a low-modeling low-code open-source platform built on top
  of our Python-based personal interpretation of a "Universal Modeling Language"


  We have tested B-OCL with python 3.9+. We recommend creating a virtual environment using `venv <https://docs.python.org/3/tutorial/venv.html>`_, or
  `conda <https://docs.conda.io/en/latest/>`_).

  Dependencies
  ************
  B-OCL depends on BESSER for parsing the OCL constraints and providing a concrete syntax tree (CST) to evaluate. The latest stable version of BESSER is available in the Python Package Index (PyPi) and can be installed using


      $ pip install besser





  Stable version of B-OCL interpreter can be installed via

      $ pip install bocl



  To obtain the full code, including examples and tests, you can clone the git repository.

      $ git clone https://github.com/BESSER-PEARL/b-ocl-Interpreter
      $ cd b-ocl-Interpreter

  To install the reqs please run the following commands in virtual environment (recommended)

      $ pip install -r requirements.txt



  We encourage contributions from the community and any comment is welcome!

  If you are interested in contributing to this project, please read the [CONTRIBUTING.md](CONTRIBUTING.md) file.



  At BESSER, our commitment is centered on establishing and maintaining development environments that are welcoming, inclusive, safe and free from all forms of harassment. All participants are expected to voluntarily respect and support our [Code of Conduct](CODE_OF_CONDUCT.md).



  The development of this project follows the governance rules described in the [GOVERNANCE.md](GOVERNANCE.md) document.


  You can reach us at: [info@besser-pearl.org](mailto:info@besser-pearl-org)

  Website: https://besser-pearl.github.io/website/


  More details about B-OCL can be found here https://b-ocl-interpreter.readthedocs.io/en/latest/



  This project is licensed under the [MIT](https://mit-license.org/) license.


pkgId: 886913845554ca181d64abd51338fac6ee35c8ebd010b3a332e5ca62082369f8
name: python-bocoel
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Bayesian Optimization as a Coverage Tool for Evaluating Large Language Models
url: https://pypi.org/project/bocoel/
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bocoel-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ![Logo](assets/logo-full.svg)

  [![Publish](https://github.com/rentruewang/bocoel/actions/workflows/release.yaml/badge.svg)](https://github.com/rentruewang/bocoel/actions/workflows/release.yaml)
  [![Build Pages](https://github.com/rentruewang/bocoel/actions/workflows/build.yaml/badge.svg)](https://github.com/rentruewang/bocoel/actions/workflows/build.yaml)
  [![Formatting](https://github.com/rentruewang/bocoel/actions/workflows/format.yaml/badge.svg)](https://github.com/rentruewang/bocoel/actions/workflows/format.yaml)
  [![Type Checking](https://github.com/rentruewang/bocoel/actions/workflows/typecheck.yaml/badge.svg)](https://github.com/rentruewang/bocoel/actions/workflows/typecheck.yaml)
  [![Unit Testing](https://github.com/rentruewang/bocoel/actions/workflows/unittest.yaml/badge.svg)](https://github.com/rentruewang/bocoel/actions/workflows/unittest.yaml)


  ![GitHub License](https://img.shields.io/github/license/rentruewang/bocoel)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue)




  Large language models are expensive and slow behemoths, and evaluating them on gigantic modern datasets only makes it worse.

  If only there is a way to just select a meaningful (_and small_) subset of the corpus and obtain a highly accurate evaluation.....

  Wait, sounds like Bayesian Optimization!

  Bocoel works in the following steps:

  1. Encode individual entry into embeddings (way cheaper / faster than LLM and reusable).
  2. Use Bayesian optimization to select queries to evaluate.
  3. Use the queries to retrieve from our corpus (with the encoded embeddings).
  4. Profit.

  The evaluations generated are easily managed by the provided manager utility.

  To our knowledge, this is the first work aiming to reduce computation costs during evaluation (benchmarking) with a (possibly dynamic) budget.




  - 🎯 Accurately evaluate large language models with just tens of samples from your selected corpus.
  - 💂‍♂️ Uses the power of Bayesian optimization to select an optimal subset of samples for the language model to evaluate.
  - 💯 Evaluate the corpus on the model in addition to evaluating the model on the corpus.
  - 🤗 Support for `GPT2`, `Pythia`, `LLAMA` and more through integration with huggingface [transformers](https://huggingface.co/docs/transformers/en/index) and [datasets](https://huggingface.co/docs/datasets/en/index)
  - 🧩 Modular design.
  - 🔎 Efficient representation of the corpus / dataset such as N-sphere representation or whitening of the latent space to augment evaluation quality.




  Like what you see? Please consider giving this a star (★)!




  <img src="https://upload.wikimedia.org/wikipedia/commons/0/02/GpParBayesAnimationSmall.gif" width="30%" align="right"/>

  Simply put, Bayesian optimization aims to optimize either the exploration objective (the purple area in the image) or the exploitation object (the height of the black dots). It uses Gaussian processes as a backbone for inference, and uses an **acquisition function** to decide where to sample next. See [here](https://distill.pub/2019/visual-exploration-gaussian-processes/) for an a more in-depth introduction.

  Since _Bayesian optimization works well with an expensive-to-evaluate black-box model (paraphrase: LLM)_, it is perfect for this particular use case. Bocoel uses Bayesian optimization as a backbone for exploring the embedding space given by our corpus, which allows it to select a good subset acting as a mini snapshot of the corpus.




  LLMs are painfully slow, especially generative ones (which is what is usually referred to as LLM), since sequence generation is sequential by nature.

  Despite `bocoel`'s requirement to use an embedder to encode the entire corpus, embedders are faster than LLMs by orders of magnitude and the time is gained back by practically any savings in evaluating LLMs.




  I don't want optional dependencies:

  ```
  pip install bocoel
  ```

  Give me the full experience (all optional dependencies):

  ```
  pip install "bocoel[all]"
  ```




  See the folder [examples/getting_started](https://github.com/rentruewang/bocoel/tree/main/examples/getting_started) for a simplistic usage of the library to get started with just a few lines of code.




  Usage examples are under the folder [`examples`](https://github.com/rentruewang/bocoel/tree/main/examples). API reference can be found [here](https://bocoel.rentruewang.com/references/overview.html).




  Contributors wanted! Don't be shy. Feel free to file issues and PRs. For PRs, please follow the guide on [contributing](./CONTRIBUTING.md) and the [code of conduct](./CODE_OF_CONDUCT.md). Openness and inclusiveness are taken very seriously.




  - 🪑 Simpler usage. I should provide a high-level wrapper for the entire library s.t. evaluations can be run in one line.
  - 📊 Visualization module of the evaluation.
  - 🎲 Integration of alternative methods (random, kmedoids...) with Gaussian process.
  - 🥨 Integration with more backends such as [VLLM](https://github.com/vllm-project/vllm) and [OpenAI's API](https://github.com/openai/openai-python).
  - 🆕 Support for Python 3.12+




  The code is available under [BSD-3 License](./LICENSE.md).

  If you find this project helpful in your research, please cite this work at

  ```
  @misc{bocoel2024,
      title = {BoCoEL: Bayesian Optimization as a Coverage Tool for Evaluating Large Language Models},
      url = {https://bocoel.rentruewang.com/research/},
      author = {Wang, RenChu},
      month = {January},
      year = {2024}
  }
  ```


pkgId: 904477f74f9da139a0455cefdf0c6520e912322f3b32bca9b75878ca73245686
name: python-boddle
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: A unit testing tool for Python's bottle library.
url: https://github.com/keredson/boddle
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boddle-0.2.9-1.src.rpm
checksum_type: sha256
description:
  A unit testing tool for Python’s bottle library. We wrote this for our
  own testing purposes at https://www.hvst.com. Thanks
  `brenguyen711 <https://github.com/brenguyen711>`__ for the great name!


pkgId: 3bc441e8826fec50cf65790a2ae8cfe59041aa9ca0d633862bc98f2e823afa12
name: python-bodoTK
arch: src
version: 0.1
epoch: 0
release: 1
summary: A tokenization library for Bodo language
url: https://github.com/tsong44/bodoTK
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bodoTK-0.1-1.src.rpm
checksum_type: sha256
description:
  **bodoTK** is a Python library designed for tokenization of the Bodo language. This library provides functions to perform sentence-level, word-level, and character-level tokenization.



  - Sentence-level tokenization
  - Word-level tokenization
  - Character-level tokenization



  You can install `bodoTK` using `pip`. To install it locally, use the following command:

  ```bash
  pip install /path/to/your/package/bodoTK-0.1-py3-none-any.whl


pkgId: 26ec3f30afe556fbb3e792513f9cbbd1d4bf95041d2d1f99b5736214671b9ce7
name: python-body_scan
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Health Checks
url: https://pypi.org/project/body_scan/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-body_scan-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Bravo! You have received a Medical Diploma in "body_scan" from
  the Orbital Convergence University International Air and Water
  Embassy of the Tangerine Planet.

  You are now officially certified to include "body_scan" in your
  practice.

  <body>
  	<header>
  		<address>body scan</address>
  	</header>

  	<main>
  		<address>quick start</address>

  		<p>How to start the status checks</p>
  		<code python3>

  		'''
  			The example is based on this structure:

  			/example_module_a
  				/status
  					/modules_pip			# the location of body_scan

  					modules_pip.UTF8 		# The requirements of the modules required to check
  											
  											
  											
  											
  											

  					status.py				# this is the file where body_scan is called from.

  				/structures
  					/modules_pip			# the location of the requirements of "example_module_a"

  					/modules
  						/example_module_a	# The module being developed
  							__init__.py


  					modules_pip.UTF8 		# The requirements of example_module_a
  											


  		'''

  		
  		
  		
  		import body_scan
  		import pathlib
  		from os.path import dirname, join, normpath

  		this_folder = pathlib.Path (__file__).parent.resolve ()

  		structures = normpath (join (this_folder, "../structures")
  		the_module = normpath (join (structures, "modules/example_module_a")

  		scan = body_scan.start (
  			
  			
  			
  			glob_string = str (the_module) + '/**/status_*.py',

  			
  			
  			
  			module_paths = [
  				normpath (join (structures, "modules"),
  				normpath (join (structures, "modules_pip")
  			],
  			simultaneous = True,
  			relative_path = normpath (join (structures, "modules")),
  			db_directory = normpath (join (this_folder, "DB"),


  			before = normpath (join (this_folder, "before.py")),
  			after = normpath (join (this_folder, "after.py"))
  		)

  		status = scan ["status"]
  		paths = status ["paths"]

  		</code>

  		<b>body_scan.start options</b>
  		<code>
  			required

  			
  			
  			
  			glob_string = search + '/**/status_*.py',

  		</code>

  		<code>
  			optional

  			
  			
  			
  			
  			
  			
  			simultaneous = True,

  			
  			
  			
  			module_paths = [
  				normpath (join (search, "modules_pip"))
  			],

  			
  			
  			
  			relative_path = search


  			
  			
  			
  			
  			db_directory

  			
  			
  			
  			
  			before

  			
  			
  			
  			after

  		</code>

  		<b>How to write checks</b>
  		<code python3>
  			def check_1 ():
  				print ("check 1")

  			def check_2 ():
  				raise Exception ("NOT 100%")


  			checks = {
  				"check 1": check_1,
  				"check 2": check_2
  			}
  		</code>


  		<b>output</b>

  		output is printed in 3 sections:
  			status:
  				empty = true -> no "checks" were found
  				parsed = true -> the python3 exec compiler could parse the file

  			alarms
  			stats

  		<code python3>
  		status: {
  			"paths": [
  				{
  					"path": "guarantee_1.py",
  					"empty": false,
  					"parsed": true,
  					"stats": {
  						"passes": 1,
  						"alarms": 1
  					},
  					"checks": [
  						{
  							"check": "check 1",
  							"passed": true,
  							"elapsed": [
  								1.07790001493413e-05,
  								"SECONDS"
  							]
  						},
  						{
  							"check": "check 2",
  							"passed": false,
  							"exception": "Exception('NOT 100%')",
  							"exception trace": [
  								"Traceback (most recent call last):",
  								"  File \"/body_scan/processes/scan/keg/scan.py\", line 68, in scan",
  								"    checks [ check ] ()",
  								"  File \"<string>\", line 10, in check_2",
  								"Exception: NOT 100%"
  							]
  						}
  					]
  				}
  			],
  			"stats": {
  				"alarms": 0,
  				"empty": 0,
  				"checks": {
  					"passes": 1,
  					"alarms": 1
  				}
  			}
  		}
  		alarms: [
  			{
  				"path": "guarantee_1.py",
  				"checks": [
  					{
  						"check": "check 2",
  						"passed": false,
  						"exception": "Exception('NOT 100%')",
  						"exception trace": [
  							"Traceback (most recent call last):",
  							"  File \"/body_scan/structure/modules/body_scan/processes/scan/keg/scan.py\", line 68, in scan",
  							"    checks [ check ] ()",
  							"  File \"<string>\", line 10, in check_2",
  							"Exception: NOT 100%"
  						]
  					}
  				]
  			}
  		]
  		stats: {
  			"alarms": 0,
  			"empty": 0,
  			"checks": {
  				"passes": 1,
  				"alarms": 1
  			}
  		}
  		</code>
  	</main>
  </body>


pkgId: b2470760e51ee4cd05041b9e42d3e1f35cf04b3e455ec0a05a14e942efeac4a3
name: python-bogons
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Python Libary for IP & ASN Bogons
url: https://github.com/mellowdrifter/python-bogons
rpm_license: Apache Software License (http://www.apache.org/licenses/LICENSE-2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bogons-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Python version of [https://github.com/mellowdrifter/bogons](https://github.com/mellowdrifter/bogons)


  Python library to validate IP and ASN [bogons](https://en.wikipedia.org/wiki/Bogon_filtering).
  This library does not filter out unassigned space. It will filter IPv4, IPv6, and Autonomous system numbers that have been marked as bogons in the following RFCs:
  * [RFC1918](https://tools.ietf.org/html/rfc1918)
  * [RFC1930](https://tools.ietf.org/html/rfc1930)
  * [RFC4893](https://tools.ietf.org/html/rfc4893)
  * [RFC5398](https://tools.ietf.org/html/rfc5398)
  * [RFC6483](https://tools.ietf.org/html/rfc6483)
  * [RFC6793](https://tools.ietf.org/html/rfc6793)
  * [RFC6996](https://tools.ietf.org/html/rfc6996)
  * [RFC7300](https://tools.ietf.org/html/rfc7300)
  * [RFC7607](https://tools.ietf.org/html/rfc7607)

  For IPv6: 6to4, 6bone, and any prefix not in 2000::/3 is marked as invalid.



  ```pip install bogons```


  ```
  import bogons
  >>> bogons.is_public_ip("1.1.1.1")
  True
  >>> bogons.is_public_ip("10.0.0.0")
  False
  >>> bogons.is_public_ip("2600::")
  True
  >>> bogons.is_public_ip("4600::")
  False
  >>> bogons.valid_public_asn(1)
  True
  >>> bogons.valid_public_asn(23456)
  False
  ```


  I welcome pull requests for updated RFCs or errors.


pkgId: d48347b76af2d7c705ed74105a3c4cf4219397a9e0dc2da4097db394f820e25b
name: python-bohra
arch: src
version: 2.3.7
epoch: 0
release: 1
summary: A bioinformatics pipeline for analysing short read Illumina data microbiological public health.
url: https://github.com/kristyhoran/bohra
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bohra-2.3.7-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/MDU-PHL/bohra/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/MDU-PHL/bohra/tree/master)
  [![Python 3.9](https://img.shields.io/badge/python-3.9-blue.svg)](https://www.python.org/downloads/release/python-390/)




  Bohra is microbial genomics pipeline, designed predominantly for use in public health, but may also be useful in research settings. At a minimum the pipeline takes as input a tab-delimited file with the isolate IDs followed by the path to READ1 and READ2, where reads are illumina reads (other platforms are not supported at this stage).

  For detailed usage information please see our [wiki](https://github.com/MDU-PHL/bohra/wiki)


  * Install script to setup dependencies for you.
  * babykraken download as part of the dependency installation.
  * Addition of typers
      * [Kleborate](https://github.com/klebgenomics/Kleborate/wiki)
      * [stype](https://github.com/MDU-PHL/salmonella_typing) (NATA accredited ISO15189)
      * [meningotype](https://github.com/MDU-PHL/meningotype) (NATA accredited ISO15189)
      * [lissero](https://github.com/MDU-PHL/lissero) (NATA accredited ISO15189)
      * [ngmaster](https://github.com/MDU-PHL/ngmaster)
      * [ectyper](https://github.com/phac-nml/ecoli_serotyping)

  **Comming soon**

  * Improved report structure
  * Mtb AMR


  **Accreditation**

  Many of the underlying tools of the bohra pipeline are NATA accredited by [MDU](https://biomedicalsciences.unimelb.edu.au/departments/microbiology-Immunology/research/services/) Victoria Australia (ISO1589).

  * `snippy` and `snippy-core` version 4.4.5
  * `abritamr`
  * `stype`
  * `meningotype`
  * `lissero`



  Bohra was inspired by Nullarbor (https://github.com/tseemann/nullarbor) to be used in public health microbiology labs for analysis of short reads from microbiological samples. The pipeline is written in [Nextflow](https://www.nextflow.io).



  Bohra the name of an exinct species of tree kangaroo that lived on the Nullarbor plain in Australia. The name was chosen to reflect the fact that it will be predominantly used to build *trees*, relies on [*snippy*](https://github.com/tseemann/snippy) (named for a very famous kangaroo) and was inspired by [*nullarbor*](https://github.com/tseemann/nullarbor).


pkgId: 77a13b4213f6bcf1a9fb17f23c93c447fdd69c321183c372d91d7319ae409156
name: python-boilermaker-servicebus
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: An async python Background task system using Azure Service Bus Queues
url: https://pypi.org/project/boilermaker-servicebus/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boilermaker-servicebus-0.4.0-1.src.rpm
checksum_type: sha256
description:
  This project is an extremely-lightweight task-runner exclusively for __async Python__ and Azure Service Bus Queues. If you need a fully fledged task-runner, you should consider one of these other projects instead:

  - [Celery](https://github.com/celery/celery/tree/main)
  -



  ```sh
  pip install "boilermaker-servicebus"
  ```




  **Where does the name come from?**

  From [here](https://www.discogs.com/artist/632957-Boilermaker)

  **Are You Going to Add Other Queue Services?**

  No, not planning to. Consider one of the other background-task libraries.


pkgId: 7593c5bd871fd1869d414734b3505ffa27b6213a895cbdcfcf665fde06ef0af6
name: python-boilerpy3
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: Python port of Boilerpipe, for HTML boilerplate removal and text extraction
url: https://github.com/jmriebold/BoilerPy3
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boilerpy3-1.0.7-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/jmriebold/BoilerPy3/workflows/Tests/badge.svg)




  BoilerPy3 is a native Python [port](https://github.com/natural/java2python) of Christian Kohlschütter's [Boilerpipe](https://github.com/kohlschutter/boilerpipe) library, released under the Apache 2.0 Licence.

  This package is based on [sammyer's](https://github.com/sammyer) [BoilerPy](https://github.com/sammyer/BoilerPy), specifically [mercuree's](https://github.com/mercuree) [Python3-compatible fork](https://github.com/mercuree/BoilerPy). This fork updates the codebase to be more Pythonic (proper attribute access, docstrings, type-hinting, snake case, etc.) and make use Python 3.6 features (f-strings), in addition to switching testing frameworks from Unittest to PyTest.

  **Note**: This package is based on Boilerpipe 1.2 (at or before [this commit](https://github.com/kohlschutter/boilerpipe/tree/b0816590340f4317f500c64565b23beb4fb9a827)), as that's when the code was originally ported to Python. I experimented with updating the code to match Boilerpipe 1.3, however because it performed worse in my tests, I ultimately decided to leave it at 1.2-equivalent.




  To install the latest version from PyPI, execute:

  ```shell
  pip install boilerpy3
  ```

  If you'd like to try out any unreleased features you can install directly from GitHub like so:

  ```shell
  pip install git+https://github.com/jmriebold/BoilerPy3
  ```






  The top-level interfaces are the Extractors. Use the `get_content()` methods to extract the filtered text.

  ```python
  from boilerpy3 import extractors

  extractor = extractors.ArticleExtractor()


  content = extractor.get_content_from_url('http://example.com/')


  content = extractor.get_content_from_file('tests/test.html')


  content = extractor.get_content('<html><body><h1>Example</h1></body></html>')
  ```




  To extract the HTML chunks containing filtered text, use the `get_marked_html()` methods.

  ```python
  from boilerpy3 import extractors

  extractor = extractors.ArticleExtractor()


  content = extractor.get_marked_html_from_url('http://example.com/')


  content = extractor.get_marked_html_from_file('tests/test.html')


  content = extractor.get_marked_html('<html><body><h1>Example</h1></body></html>')
  ```




  Alternatively, use `get_doc()` to return a Boilerpipe document from which you can get more detailed information.

  ```python
  from boilerpy3 import extractors

  extractor = extractors.ArticleExtractor()

  doc = extractor.get_doc_from_url('http://example.com/')
  content = doc.content
  title = doc.title
  ```




  All extractors have a `raise_on_failure` parameter (defaults to `True`). When set to `False`, the `Extractor` will handle exceptions raised during text extraction and return any text that was successfully extracted. Leaving this at the default setting may be useful if you want to fall back to another algorithm in the event of an error.




  Usually worse than ArticleExtractor, but simpler/no heuristics. A quite generic full-text extractor.




  A full-text extractor which is tuned towards news articles. In this scenario it achieves higher accuracy than DefaultExtractor. Works very well for most types of Article-like HTML.




  A full-text extractor which is tuned towards extracting sentences from news articles.




  A full-text extractor which extracts the largest text component of a page. For news articles, it may perform better than the DefaultExtractor but usually worse than ArticleExtractor




  A full-text extractor trained on [krdwrd](http://krdwrd.org) [Canola](https://krdwrd.org/trac/attachment/wiki/Corpora/Canola/CANOLA.pdf). Works well with SimpleEstimator, too.




  Dummy extractor which marks everything as content. Should return the input text. Use this to double-check that your problem is within a particular Extractor or somewhere else.




  A quite generic full-text extractor solely based upon the number of words per block (the current, the previous and the next block).







  While BoilerPy3 provides `extractor.*_from_url()` methods as a convenience, these are intended for testing only. For more robust functionality, in addition to full control over the request itself, it is strongly recommended to use the [Requests package](https://docs.python-requests.org/) instead, calling `extractor.get_content()` with the resulting HTML.

  ```python
  import requests
  from boilerpy3 import extractors

  extractor = extractors.ArticleExtractor()


  resp = requests.get('http://example.com/')


  content = extractor.get_content(resp.text)
  ```


pkgId: a0514ab07cc6ad611780b1254a8502af92b9269bc17515b11122e8f38a99e470
name: python-boilr
arch: src
version: 0.7.4
epoch: 0
release: 1
summary: Basic framework for training models with PyTorch
url: https://github.com/addtt/boiler-pytorch
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boilr-0.7.4-1.src.rpm
checksum_type: sha256
description:
  Basic framework for training stuff in PyTorch. It's quite tailored to projects
  I've been working on lately, so it's meant for personal use. Its sole purpose is
  to do away with `boilr`plate code, and having it here makes it easier to
  share it across projects.



  ```shell script
  pip install boilr
  ```




  There's a usage example that can be useful as template. It's a basic VAE
  for MNIST quickly hacked together. The example files are:
  - `example.py`
  - `example_evaluate.py`
  - `experiments/mnist_experiment/data.py`
  - `experiments/mnist_experiment/experiment_manager.py`
  - `models/mnist_vae.py`

  Install requirements and run the example:

  ```shell script
  pip install -r requirements.txt
  CUDA_VISIBLE_DEVICES=0 python example.py
  ```

  For evaluation:

  ```shell script
  CUDA_VISIBLE_DEVICES=0 python example_evaluate.py --ll --ll-samples 100 --load $RUN_NAME
  ```
  using the name of the folder in `output/` generated from running the example.








  The following functionalities are available out-of-the-box:
  - Easy logging of metrics to tensorboard and to a pickle file. Metrics are collected at every training step, smoothed, and logged/saved at a specified frequency. The amount of smoothing is also customizable.
  - Summaries of the metrics are automatically printed after each training and testing phase. This can be easily customized.
  - Training speed, gradient norm (global and per-parameter), and L2 norm of the model parameters are all automatically logged.
  - It's easy to save images from testing, in a dedicated folder.
  - Gradient clipping (by global norm), controllable through a command-line argument.
  - Automatic model checkpointing, with command-line argument to control the maximum number of recent checkpoints to be kept.
  - Command-line argument to resume training from checkpoint, and everything is taken care of.
  - Progress bar for training and testing, using `tqdm`. Can be switched off.
  - Data-dependent initialization (command-line argument).
  - Reproducibility: set random seed across all devices and Python libraries.
  - A suite of utility classes and methods in the packages `boilr.nn` and `boilr.utils` (most of them for internal use).
  In particular `boilr.nn.modules` and `boilr.utils.viz` might be more generally useful.
  - A long list of command-line arguments to control some of the behaviour above.
  Some arguments are not directly used, but it's convenient to have them already defined: e.g. if a custom `DataLoader` is necessary, the batch size is easily accessible with `args.batch_size`; and when creating the optimizer, the learning rate is `args.lr`.
  - See `boilr.options` for package-wide options. Usually it's not necessary to change them, but they give some more flexibility.



  There are built-in command-line arguments with default values. These defaults can be easily
  overridden programmatically when making the experiment class that subclasses `boilr`'s.
  The built-in arguments are the following:
  - `batch-size`: training batch size (default: None)
  - `test-batch-size`: test batch size (default: None)
  - `lr`: learning rate (default: None)
  - `max-grad-norm`: maximum global norm of the gradient. It is clipped if larger. If None, no clipping is performed. (default: None)
  - `seed`: random seed (default: 54321)
  - `tr-log-every`: log training metrics every this number of training steps (default: 1000)
  - `ts-log-every`: log test metrics every this number of training steps. It must be a multiple of `--tr-log-every` (default: 1000)
  - `ts-img-every`: save test images every this number of training steps. It must be a multiple of `--ts-log-every` (default: same as `--ts-log-every`)
  - `checkpoint-every`: save model checkpoint every this number of training steps (default: 1000)
  - `keep-checkpoint-max`: keep at most this number of most recent model checkpoints (default: 3)
  - `max-steps`: max number of training steps (default: 1e10)
  - `max-epochs`: max number of training epochs (default: 1e7)
  - `nocuda`: do not use cuda (default: False)
  - `descr`: additional description for experiment name
  - `dry-run`: do not save anything to disk (default: False)
  - `resume`: load the run with this name and resume training

  Additionally, for `VAEExperimentManager`, the following arguments are available:
  - `ll-every`: evaluate log likelihood (with the importance-weighted bound) every this number of training steps (default: 50000)
  - `ll-samples`: number of importance-weighted samples to evaluate log likelihood (default: 100)




  1. subclass a base dataset manager class;
  2. subclass a base model class;
  3. subclass a base experiment manager class (the model class is used in here);
  4. make a short script that creates the experiment object, uses it to create a `boilr.Trainer`, and runs the trainer;
  5. optionally, subclass the base evaluator to set up an "offline" evaluation pipeline.

  See below for more details.



  The class `boilr.data.BaseDatasetManager` must be subclassed. The subclass *must* implement
  the method `_make_datasets` which should return a tuple `(train, test)` with the training
  and test sets as PyTorch `Dataset`s.
  A basic implementation of `_make_dataloaders` is already provided, but can be overridden to make
  custom data loaders.




  One of the model classes must be subclassed to inherit core methods in the base implementation `boilr.models.BaseModel`.
  These models also automatically subclass `torch.nn.Module` (so it must implement `forward`).
  In addition, `boilr.models.BaseGenerativeModel` (subclassing `BaseModel`) defines a method `sample_prior` that must be implemented by subclasses.




  One of the base experiment classes in `boilr.experiments` must be subclassed. The subclass *must* implement:
  - `_make_datamanager` to create the dataset manager, which should subclass `boilr.data.BaseDatasetManager`;
  - `_make_model` to create the model, which should subclass `boilr.models.BaseModel`;
  - `_make_optimizer` to create the optimizer, which should subclass `torch.optim.optimizer.Optimizer`;
  - `forward_pass` to perform a simple single-pass model evaluation and returns losses and metrics;
  - `test_procedure` to evaluate the model on the test set (usually heavily based on the `forward_pass` method).

  Typically should be overridden:
  - `_define_args_defaults`, `_add_args`, and `_check_args` (or a subset of these) to manage parsing of command-line arguments;
  - `_make_run_description` which returns a string description of the run, used for output folders;
  - `save_images` to save output images (e.g. reconstructions and samples in VAEs).

  May be overridden for additional control:
  - `post_backward_callback` is called by the `Trainer` after the backward pass but before the optimization step;
  - `get_metrics_dict` translates a dictionary of results to a dictionary of metrics to be logged (by default this simply copies over the keys);
  - `train_log_str` and `test_log_str` return log strings for test and training metrics.

  **Note**: The class `VAEExperimentManager` implements default `test_procedure` and `save_images`
  methods for variational inference with VAEs.




  ```python
  from boilr import Trainer
  from my_experiment import MyExperimentClass

  if __name__ == "__main__":
      experiment = MyExperimentClass()
      trainer = Trainer(experiment)
      trainer.run()
  ```




  If offline evaluation is necessary, `boilr.eval.BaseOfflineEvaluator` can be subclassed by implementing:

  - `run` to run the evaluation;
  - as above, `_define_args_defaults`, `_add_args`, and `_check_args` (or a subset of these) to manage parsing of command-line arguments.

  The method `run` can be executed by simply calling the evaluator object.
  See `example_evaluate.py`.





  - It also works without `tensorboard`, but it won't save tensorboard logs.


pkgId: 93c4cb2dc97067abcbaa2e7abd38b1c26af0202bbff77d8cf6d2e9d8de1294a4
name: python-boinc-client
arch: src
version: 1.12.1
epoch: 0
release: 1
summary: Python API for interacting with a BOINC client via RPC
url: https://pypi.org/project/boinc-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boinc-client-1.12.1-1.src.rpm
checksum_type: sha256
description:
  ![Test and Release](https://github.com/SplinterHead/boinc-client/actions/workflows/test-and-release.yml/badge.svg)
  [![boinc-client](https://snyk.io/advisor/python/boinc-client/badge.svg)](https://snyk.io/advisor/python/boinc-client)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/boinc-client)


  Python native library for interacting with a BOINC client via RPC. This library has been designed to have consistent response types.





  ```python
  from boinc_client import Boinc
  from boinc_client.clients.rpc_client import RpcClient


  BOINC_HOSTNAME = "192.168.0.2"


  rpc_client = RpcClient(hostname=BOINC_HOSTNAME)
  rpc_client.authenticate()


  boinc_client = Boinc(rpc_client=rpc_client)
  ```


  The following options can be passed when creating an `RpcClient` instance

  | Argument   | Description                                                                | Required | Default |
  |------------|----------------------------------------------------------------------------|----------|---------|
  | `hostname` | Hostname or IP address of the BOINC client                                 | Yes      | None    |
  | `port`     | Exposed port of the BOINC client                                           | No       | 31416   |
  | `timeout`  | Seconds to wait for a successful connection to the RPC socket              | No       | 30      |
  | `password` | Password to authenticate to the BOINC client, required for most operations | No       | None    |


  The following options can be passed when creating a `Boinc` instance

  | Argument     | Description                        | Required | Default |
  |--------------|------------------------------------|----------|---------|
  | `rpc_client` | Instance of a configured RpcClient | Yes      | None    |



  * [Unauthorised Operations](docs/unauthorised.md)
  * [Project Operations](docs/project.md)



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

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->


pkgId: a45e97602bed257ae2af0a5e56261b04f5fe42313cf4c718f7aa858e46b05ac8
name: python-boj-cli
arch: src
version: 1.2.9
epoch: 0
release: 1
summary: Command line interface for BOJ
url: https://pypi.org/project/boj-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boj-cli-1.2.9-1.src.rpm
checksum_type: sha256
description:
  ```sh
  $ boj login
  ```
  백준 온라인 저지에서는 로그인 시 `reCAPTCHA`를 사용하고있기 때문에 로그인 과정은 조금 번거로울 수 있습니다.
  위 명령어를 실행하면 `selenium` 브라우저가 실행되고, `reCAPTCHA`를 포함한 로그인을 수행하면 세션 정보를 로컬 디렉토리 `$HOME/.boj-cli`에 암호화해서 저장합니다.


pkgId: df27c79d7628176459e38d66d0ecba2e522420d35e82dfd3c786293dd8b43a84
name: python-bojan
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: A simple logging library
url: https://github.com/daniilgrydin/bojan.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bojan-0.0.14-1.src.rpm
checksum_type: sha256
description:
  BojanConsole is a Python library designed to enhance console logging with various message types and color-coded outputs.



  To install Bojan simply run

  ```bash
  pip install bojan
  ```



  A [VS Code extension](https://github.com/daniilgrydin/bojan-vscode-highlighter) is available to highlight the .bojan and .bjn log files.







  ```python
  from bojan import BojanConsole

  console = BojanConsole(printing=True)
  ```
  > Note that `printing` decides whether the instance will print to terminal or just store logs for later use.



  - **Info Message**:
      ```python
      console.print("This is an info message.", identifier="🗣️", depth=0)
      ```
      output:
      ```
      🗣️ This is an info message.
      ```

  - **Debug Message**:
      ```python
      console.debug("This is a debug message.")
      ```
      output:
      ```
      💬 This is a debug message.
      ```

  - **Error Message**:
      ```python
      console.error("This is an error message.")
      ```
      output:
      ```
      ❌ This is an error message.
      ```

  - **Success Message**:
      ```python
      console.success("This is a success message.")
      ```
      output:
      ```
      ✅ This is a success message.
      ```

  - **Warning Message**:
      ```python
      console.warning("This is a warning message.")
      ```
      output:
      ```
      ⚠️ This is a debug message.
      ```



  ```python
  sample_dict = {"key1": "value1", "key2": {"subkey1": "subvalue1"}}
  console.dictionary(sample_dict)
  ```
  output:
  ```
  🏰 key1
      🛖 value1
      🛖 subkey1
          🌲 subvalue 1
  ```
  > The emojis use following hierarchy: 🏰 🛖 🌲 🐦 🐛 🧬



  The depth parameter of all logging functions determines how nested the message is by inserting a corresponding amount of tabs.

  ```python
  console.print("Message!", depth=0)
  console.print("Nested message!", depth=1)
  console.error("Nested error message!", depth=1)
  ```

  output:

  ```
  🕸️ Message!
      🕸️ Nested message!
      ❌ Nested error message!
  ```



  ```python
  console.save("logfile.bojan")
  ```



  This project is licensed under the MIT License.



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


pkgId: 05863d3cb0c0020ff028f49080afc3833760a4d7c788d63e352063095acb46cf
name: python-bok-choy
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Deprecated UI-level acceptance test framework
url: http://github.com/openedx/bok-choy
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bok-choy-2.0.2-1.src.rpm
checksum_type: sha256
description:
  UI-level acceptance test framework.  `Full documentation available on ReadTheDocs`__.
  __ http://bok-choy.readthedocs.org/en/latest/


pkgId: e55be83ec9ad19996364c0ca0f2962fb51a20c2655cee6214c1408822c40fe27
name: python-bokeh
arch: src
version: 3.5.2
epoch: 0
release: 1
summary: Interactive plots and applications in the browser from Python
url: https://pypi.org/project/bokeh/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bokeh-3.5.2-1.src.rpm
checksum_type: sha256
description:
  [Bokeh](https://bokeh.org) is an interactive visualization library for modern web browsers. It provides elegant, concise construction of versatile graphics and affords high-performance interactivity across large or streaming datasets. Bokeh can help anyone who wants to create interactive plots, dashboards, and data applications quickly and easily.
  <table>
  <tr>
    <td>Package</td>
    <td>
      <img src="https://img.shields.io/pypi/v/bokeh?label=Version&color=ECD078&style=for-the-badge"
           alt="Latest package version" />
    </td>
    <td>
      <a href="https://docs.bokeh.org/en/latest/docs/first_steps/installation.html">
      <img src="https://img.shields.io/pypi/pyversions/bokeh?color=ECD078&style=for-the-badge"
           alt="Supported Python versions" />
      </a>
    </td>
    <td>
      <a href="https://github.com/bokeh/bokeh/blob/-/LICENSE.txt">
      <img src="https://img.shields.io/github/license/bokeh/bokeh.svg?color=ECD078&style=for-the-badge"
           alt="Bokeh license (BSD 3-clause)" />
      </a>
    </td>
  </tr>
  <tr>
    <td>Project</td>
    <td>
      <img src="https://img.shields.io/github/contributors-anon/bokeh/bokeh?color=ECD078&style=for-the-badge"
           alt="Github contributors" />
    </td>
    <td>
      <a href="https://numfocus.org">
      <img src="https://img.shields.io/badge/sponsor-numfocus-ECD078?style=for-the-badge"
           alt="Link to NumFOCUS" />
      </a>
    </td>
    <td>
      <a href="https://docs.bokeh.org/en/latest/">
      <img src="https://img.shields.io/badge/documentation-latest-ECD078?style=for-the-badge"
           alt="Link to documentation" />
      </a>
    </td>
  </tr>
  <tr>
    <td>Downloads</td>
    <td>
      <a href="https://docs.bokeh.org/en/latest/docs/first_steps/installation.html">
      <img src="https://img.shields.io/pypi/dm/bokeh?color=D98B43&label=pypi&logo=python&logoColor=yellow&style=for-the-badge"
           alt="PyPI downloads per month" />
      </a>
    </td>
    <td>
      <a href="https://docs.bokeh.org/en/latest/docs/first_steps/installation.html">
      <img src="https://img.shields.io/conda/d/conda-forge/bokeh?style=for-the-badge&logo=python&color=D98B43&logoColor=yellow"
           alt="Conda downloads per month" />
      </a>
    </td>
    <td>
      <a href="https://www.npmjs.com/package/@bokeh/bokehjs">
      <img src="https://img.shields.io/npm/dm/%40bokeh/bokehjs?style=for-the-badge&logo=npm&label=NPM&color=D98B43"
           alt="NPM downloads per month" />
      </a>
    </td>
  </tr>
  <tr>
    <td>Build</td>
    <td>
      <a href="https://github.com/bokeh/bokeh/actions">
      <img src="https://img.shields.io/github/actions/workflow/status/bokeh/bokeh/bokeh-ci.yml?label=Bokeh-CI&logo=github&style=for-the-badge"
           alt="Current Bokeh-CI github actions build status" />
      </a>
    </td>
    <td>
      <a href="https://github.com/bokeh/bokeh/actions">
      <img src="https://img.shields.io/github/actions/workflow/status/bokeh/bokeh/bokehjs-ci.yml?label=BokehJS-CI&logo=github&style=for-the-badge"
           alt="Current BokehJS-CI github actions build status" />
      </a>
    </td>
    <td>
      <a href="https://codecov.io/gh/bokeh/bokeh" >
      <img src="https://img.shields.io/codecov/c/github/bokeh/bokeh?logo=codecov&style=for-the-badge&token=bhEzGkDUaw"
           alt="Codecov coverage percentage" />
      </a>
    </td>
  </tr>
  <tr>
    <td>Community</td>
    <td>
      <a href="https://discourse.bokeh.org">
      <img src="https://img.shields.io/discourse/https/discourse.bokeh.org/posts.svg?color=blue&logo=discourse&style=for-the-badge"
           alt="Community support on discourse.bokeh.org" />
      </a>
    </td>
    <td>
      <a href="https://stackoverflow.com/questions/tagged/bokeh">
      <img src="https://img.shields.io/stackexchange/stackoverflow/t/%5Bbokeh%5D?style=for-the-badge&logo=stackoverflow&label=stackoverflow&color=blue"
           alt="Bokeh-tagged questions on Stack Overflow" />
       </a>
    </td>
  </tr>
  </table>
  *Consider [making a donation](https://opencollective.com/bokeh) if you enjoy using Bokeh and want to support its development.*
  ![4x9 image grid of Bokeh plots](https://user-images.githubusercontent.com/1078448/190840954-dc243c99-9295-44de-88e9-fafd0f4f7f8a.jpg)

  To install Bokeh and its required dependencies using `pip`, enter the following command at a Bash or Windows command prompt:
  ```
  pip install bokeh
  ```
  To install `conda`, enter the following command at a Bash or Windows command prompt:
  ```
  conda install bokeh
  ```
  Refer to the [installation documentation](https://docs.bokeh.org/en/latest/docs/first_steps/installation.html) for more details.

  Once Bokeh is installed, check out the [first steps guides](https://docs.bokeh.org/en/latest/docs/first_steps.html#first-steps-guides).
  Visit the [full documentation site](https://docs.bokeh.org) to view the [User's Guide](https://docs.bokeh.org/en/latest/docs/user_guide.html) or [launch the Bokeh tutorial](https://mybinder.org/v2/gh/bokeh/bokeh-notebooks/HEAD?labpath=index.ipynb) to learn about Bokeh in live Jupyter Notebooks.
  Community support is available on the [Project Discourse](https://discourse.bokeh.org).
  If you would like to contribute to Bokeh, please review the [Contributor Guide](https://docs.bokeh.org/en/latest/docs/dev_guide.html) and [request an invitation to the Bokeh Dev Slack workspace](https://slack-invite.bokeh.org/).
  *Note: Everyone who engages in the Bokeh project's discussion forums, codebases, and issue trackers is expected to follow the [Code of Conduct](https://github.com/bokeh/bokeh/blob/branch-3.0/docs/CODE_OF_CONDUCT.md).*


  The Bokeh project is grateful for [individual contributions](https://opencollective.com/bokeh), as well as for monetary support from the organizations and companies listed below:
  <table align="center">
  <tr>
    <td>
      <a href="https://www.numfocus.org/">
      <img src="https://static.bokeh.org/sponsor/numfocus.svg"
           alt="NumFocus Logo" width="200"/>
      </a>
    </td>
    <td>
      <a href="https://chanzuckerberg.com/">
      <img src="https://static.bokeh.org/sponsor/czi.svg"
           alt="CZI Logo" width="200"/>
      </a>
    </td>
    <td colspan="2">
      <a href="https://www.blackstone.com/the-firm/">
      <img src="https://static.bokeh.org/sponsor/blackstone.png"
           alt="Blackstone Logo" width="400"/>
      </a>
    </td>
   </tr>
   <tr>
    <td>
      <a href="https://tidelift.com/">
      <img src="https://static.bokeh.org/sponsor/tidelift.svg"
           alt="TideLift Logo" width="200"/>
      </a>
    </td>
    <td>
      <a href="https://www.anaconda.com/">
      <img src="https://static.bokeh.org/sponsor/anaconda.png"
           alt="Anaconda Logo" width="200"/>
      </a>
    </td>
    <td>
      <a href="https://www.nvidia.com">
      <img src="https://static.bokeh.org/sponsor/nvidia.png"
           alt="NVidia Logo" width="200"/>
      </a>
    </td>
    <td>
      <a href="https://developer.nvidia.com/rapids">
      <img src="https://static.bokeh.org/sponsor/rapids.png"
           alt="Rapids Logo" width="200"/>
      </a>
    </td>
  </tr>
  </table>
  If your company uses Bokeh and is able to sponsor the project, please contact <a href="info@bokeh.org">info@bokeh.org</a>
  *Bokeh is a Sponsored Project of NumFOCUS, a 501(c)(3) nonprofit charity in the United States. NumFOCUS provides Bokeh with fiscal, legal, and administrative support to help ensure the health and sustainability of the project. Visit [numfocus.org](https://numfocus.org) for more information.*
  *Donations to Bokeh are managed by NumFOCUS. For donors in the United States, your gift is tax-deductible to the extent provided by law. As with any donation, you should consult with your tax adviser about your particular tax situation.*

  Non-monetary support can help with development, collaboration, infrastructure, security, and vulnerability management. The Bokeh project is grateful to the following companies for their donation of services:
  * [Amazon Web Services](https://aws.amazon.com/)
  * [GitGuardian](https://gitguardian.com/)
  * [GitHub](https://github.com/)
  * [makepath](https://makepath.com/)
  * [Pingdom](https://www.pingdom.com/website-monitoring)
  * [Slack](https://slack.com)
  * [QuestionScout](https://www.questionscout.com/)
  * [1Password](https://1password.com/)

rpm_license:
  Copyright (c) Anaconda, Inc., and Bokeh Contributors All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  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.  Neither the name of Anaconda nor the names of any 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 OWNER 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: c80e18cc2c2a4eaadf4c93e4b00e2cb3fcf5ec7b628600546eb6d83f7569a035
name: python-bokeh-fastapi
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Compatibility layer between Bokeh and FastAPI
url: https://pypi.org/project/bokeh-fastapi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bokeh-fastapi-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Compatibility layer between Bokeh and FastAPI.



  ```shell
  pip install bokeh-fastapi
  ```



  Check out the guide(s) below:

  - [Panel FastAPI Integration](https://panel.holoviz.org/how_to/integrations/FastAPI.html) guide

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Philipp Rudiger and Philip Meier  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: 31bd4d3c4af9a1f523b9908f4b487280c83f75f25160c639ed1c14d3da653eae
name: python-bokeh-root-cmd
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Command line wrapper to run a Bokeh script/folder at the root URL
url: https://github.com/ideonate/bokeh-root-cmd
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bokeh-root-cmd-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Command line wrapper to run one or more named Bokeh/Panel scripts/folders as root URL.

  This project is used in [ContainDS Dashboards](https://github.com/ideonate/cdsdashboards), which is a user-friendly
  way to launch Jupyter notebooks as shareable dashboards inside JupyterHub. Also works with Bokeh, Dash, Panel, Streamlit and other visualization frameworks.

  The published PyPI/Conda packages DO NOT bring in Bokeh or Panel as explicit dependencies, so you may
  need to install those separately in your environment.



  Install using pip.

  ```bash
  pip install bokeh-root-cmd
  ```

  The file to start is specified on the command line, for example:

  ```bash
  bokeh-root-cmd ~/Dev/mybokehscript.py
  ```

  By default the server will listen on port 8888. To specify a different **port**, use the --port flag.

  ```bash
  bokeh-root-cmd --port=8888 ~/Dev/mybokehscript.py
  ```

  To use the Panel server use the --server flag.

  ```bash
  bokeh-root-cmd --server=panel ~/Dev/mybokehscript.py
  ```

  To run directly in python: `python -m bokeh_root_cmd.main <rest of command line>`



  --allow-websocket-origin

  --debug

  --ip



  In order to be able to test manually you would need to `pip install panel pytest`. This will also install bokeh.



  ```bash
  pytest tests.py
  ```



  Run `bokeh-root-cmd test_apps/test_bokeh_hello.py` and verify the app is running at `http://localhost:8888`.



  Run `bokeh-root-cmd --server=panel test_apps/test_panel_hello.py` and verify the app is running at `http://localhost:8888`.



  Run `bokeh-root-cmd test_apps/*.py` and verify the app index is running at `http://localhost:8888` and test apps at `http://localhost:8888/test_bokeh_hello` and `http://localhost:8888/test_panel_hello`.



  Run `bokeh-root-cmd --server=panel test_apps/*.py` and verify the app index is running at `http://localhost:8888` and test apps at `http://localhost:8888/test_bokeh_hello` and `http://localhost:8888/test_panel_hello`. Note that no `ready-check' app is included in the index list.

  You can also specify them individually

  Run `bokeh-root-cmd --server=panel test_apps/test_bokeh_hello.py test_apps/test_panel_hello.py` and verify the app index is running at `http://localhost:8888` and test apps at `http://localhost:8888/test_bokeh_hello` and `http://localhost:8888/test_panel_hello`. Note that no `ready-check' app is included in the index list.


  Thank you to [MarcSkovMadsen](https://github.com/MarcSkovMadsen) for contributions.



  0.1.2 - Fix for Panel root dashboard when serving multiple apps. Previously caused problems in some browsers.


pkgId: fe8209a35391e2108fed8e4dbedab85ef63eda3047269d012c323346e0a380ba
name: python-bokeh-sampledata
arch: src
version: 2024.2
epoch: 0
release: 1
summary: Sample datasets for Bokeh examples
description: This package contains sample datasets for use with Bokeh examples.
url: https://pypi.org/project/bokeh-sampledata/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bokeh-sampledata-2024.2-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) Bokeh Contributors All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  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.  Neither the name of Anaconda nor the names of any 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 OWNER 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: ae45187670d236010d66040578850baaee8dbe023f9cebbf19a519acd716731c
name: python-boldigger
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: A python package to query different databases of boldsystems.org
url: https://github.com/DominikBuchner/BOLDigger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boldigger-2.2.2-1.src.rpm
checksum_type: sha256
description:
  BOLDigger has been replaced with BOLDigger2 - check it out here: https://github.com/DominikBuchner/BOLDigger2


  ![](boldigger/data/logo.png)

  [![Downloads](https://pepy.tech/badge/boldigger)](https://pepy.tech/project/boldigger)

  Python program to query .fasta files against the different databases of www.boldsystems.org


  DNA metabarcoding data sets often consist of hundreds of Operational Taxonomic Units (OTUs), which need to be queried against databases to assign taxonomy. Barcode of Life Data system (BOLD) offers such a database that is used by many biologists. Unfortunately, only batches of 50 sequences can be identified once. Using BOLD's API does not solve the problem completely since it does not grant access to private and early release data. BOLDigger aims to solve this problem. As a pure python program with a user-friendly GUI, it not only gives automated access to the identification engine but can also be used to download additional metadata for each sequence as well as helping to choose the top hit from the returned results.

  For the command-line version please visit https://github.com/DominikBuchner/BOLDigger-commandline



  BOLDigger requires Python version 3.6 or higher and can be easily installed by using pip in any command line:

  `pip install boldigger`

  will install BOLDigger as well as all needed dependencies.
  BOLDigger can be started by typing:

  `boldigger` or `python -m boldigger`

  When a new version is released you can update by typing:

  `pip install --upgrade boldigger`



  Buchner D, Leese F (2020) BOLDigger â€“ a Python package to identify and organise sequences with the Barcode of Life Data systems. Metabarcoding and Metagenomics 4: e53535. https://doi.org/10.3897/mbmg.4.53535



  The identification engine requires an account at www.boldsystems.org. A login is required to query more than one sequence with the identification engine. User data can be saved by ticking "Remember me". **Note that your password will be saved unencrypted. Don't use this option if this is not okay.**
  Only one login per session is required.



  Once logged into the account, the identification engine of BOLD can be used. An output folder needs to be selected where the results will be saved, as well as an input file in .fasta format. Three different databases can be selected: **COI, ITS, or rbcL & matK** as well as a **batch size**. The latter handles how many sequences will be identified in one request. 50 is the maximum value as and the default for COI. Batch size depends on various parameters such as internet connection, availability of the BOLD database as well as the length of the requested sequences and needs to be adjusted if a lot of ConnectionErrors occur. A batch size of **50 is recommended for COI**, **10 for ITS**, and **< 5 for rbcL & matK.**
  The results will be written to the output folder and will always be named "BOLDResults_fastaname.xlsx". In case a workbook with that name already exists in the output folder the results will be appended to this file.
  In version 1.2.3 an option was added to check the fasta file for invalid headers and sequences before running the identification engine. If an invalid header (too long name) or invalid sequences are found (invalid characters) a modified version of this fasta will be saved in the same space as the original with a modified name. Invalid headers will be cropped to a length of 99 characters and invalid sequence characters will be replaced with N's. The modified fasta file can be used to directly run BOLDigger or the original fasta file can be checked again and edited manually.
  After every batch, the requested sequences will be removed from the input file and written to a new file named "fastaname_done.fasta" in the same folder as the input file. This is to prevent running input files twice: If BOLDigger crashes it can just be restarted with the same output folder and input file and will continue where the crash occurred.

  **The BOLD server will take some time to respond to the request. The output window will freeze during this time and updated once a response is sent.**
  **Please make sure there are no additional empty lines or invalid sequences (containing letters that don't code for bases) in your .fasta file.**

  Test input files can be found [here](https://github.com/DominikBuchner/BOLDigger/tree/master/tests)



  The standard output of the identification engine returns information about the taxonomy (Phylum, Class, Order, Family, Genus, Species and Subspecies) as well as a similarity score for each hit in the database, if the data is public, private or early-access as well as the BOLD Process ID.
  Additional data can be downloaded via the BOLD API by providing the output of the identification engine. Additional data are BOLD Record ID, BOLD BIN, Sex, Life stage, Country, Identifier, Identification method, the institution storing the sample, and a link to the specimen page. Note that in order to open the specimen page login to boldsystems.org is required.



  There are three options available to determine the best fitting hit:
  * First hit
  * JAMP Pipeline
  * BOLDigger



  This option uses the first hit and can be used for all markers supported by BOLDigger.



  This option reproduces the output from the [JAMP Pipeline](https://github.com/VascoElbrecht/JAMP). Therefore different thresholds (98%: species level, 95%: genus level, 90%: family level, 85%: order level, <85%: class level) for the taxonomic levels are used to find the best fitting hit.
  After determining the threshold for all hits the most common hit above the threshold will be selected. Note that for all hits below the threshold the taxonomic resolution will be adjusted accordingly (e.g. for a 96% hit the species level information will be discarded and genus level information will be used as the lowest taxonomic level).

  The algorithm works as follows:

  1. Find the maximum similarity value of the top 20 hits currently looked at.
  2. Set the threshold to this level, remove all hits with a similarity below this threshold (e.g. if the highest hit has 100% Similarity, the threshold will be set to 98% and all hits below will be removed for the moment.)
  3. Count all individual classifications, sort by abundance.
  4. Drop all classifications that contain missing data (e.g. if the most common hit is "Arthropoda --> Insecta" with a similarity of 100% but missing values for Order, Family, Genus and Species)
  5. Look for the most common hit that has no missing values
  6. If one is found, return that hit.
  7. If none is found, set the threshold to the next higher level and repeat the process until a hit is found.



  This option is similar to the JAMP option but flags suspicious hits. **Make sure additional data was downloaded.**
  There are currently 4 flags implemented, which will be updated if needed:

  1. Reverse BIN taxonomy has been used for any of the top 20 hits representing the selected match. (Reverse BIN taxonomy: Deposited sequences on BOLD that lack species information may be assigned by BIN affiliation. By that, a species name is shown for deposited sequences eben when no morphological identification down to species level was carried out.)

  2. There are two or more entries with differing taxonomic information above the selected threshold. (e.g. two species above 98%). Note that this is sometimes the case due to deposited sequences bearing invalid epitheton information such as "sp." or even a blank entry.

  3. All of the top 20 hits representing the top hit are private or early-release hits.

  4. The top hit result represents a unique hit of the top 20 hits.

  5. The hit has been corrected via the API correction tool.

  A closer look at all flagged hits is advised since they represent a certain degree of uncertainty for the selected hit.



  This option scans the BOLDigger top hits for hits with high similarity (>= 98%) and missing species-level assignment.
  This can happen, if the top 20 hits are populated with high similarity hits and missing species-level assignment "hide" away better hits.
  Those are queried against the BOLD identification API and corrected with the most common name in the published hits.
  The results will be saved in a new tab in the BOLDResults file for further inspection.



  * Implement the identification engine API for quick analyses
  * rework the command-line version with the new methods - will take some time
  * Add a failsafe to detect fasta format (2line, line-wrapping) and correct it before starting the search
  * Add failsaves for its and rbcl downloads
  * Add metadata async download to speed up the process


pkgId: 172782fef1edd00c44d28f22bb1282392fa0879bc43a141a168b273c084422d6
name: python-boldigger2
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: An even better python package to query different databases of boldsystems.org
url: https://github.com/DominikBuchner/BOLDigger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boldigger2-2.2.1-1.src.rpm
checksum_type: sha256
description:
  ![boldigger_logo](https://github.com/DominikBuchner/BOLDigger2/assets/38790188/0cb8ac93-139d-47df-9d78-380d76dd0033)

  [![Downloads](https://pepy.tech/badge/boldigger2)](https://pepy.tech/project/boldigger2)

  An even better Python program to query .fasta files against the COI database of www.boldsystems.org


  DNA metabarcoding datasets often comprise hundreds of Operational Taxonomic Units (OTUs), requiring querying against databases for taxonomic assignment. The Barcode of Life Data system (BOLD) is a widely used database for this purpose among biologists. However, BOLD's online platform limits users to identifying batches of only 50 sequences at a time. Additionally, using BOLD's API does not completely address this issue as it does not provide access to private and early-release data.

  BOLDigger2, the successor to BOLDigger, aims to overcome these limitations. As a pure Python program, BOLDigger2 offers:

  - Automated access to BOLD's identification engine
  - Downloading of additional metadata for each hit
  - Selection of the best-fitting hit from the returned results

  By leveraging these features, BOLDigger2 streamlines the process of OTU identification, making it more efficient and comprehensive.



  - **Unified Function**: BOLDigger2 uses a single function, `identify`, that automatically performs identification, additional data download, and selection of the top hit. This enables direct implementation into pipelines.
  - **Enhanced Database Query**: BOLDigger2 initially uses the top 100 hits from the "species level barcode records" database. If no results are found, it falls back to the "all barcode records" database.
  - **Improved Speed**: BOLDigger2 no longer alters the provided FASTA file. Instead, it generates all download links first and subsequently downloads the data asynchronously, increasing the speed almost two-fold.
  - **Secure Password Handling**: BOLDigger2 no longer asks for the password in clear text.
  - **Simplified Arguments**: The `identify` function in BOLDigger2 only accepts a single argument: the path to the FASTA file to be identified. It saves all results in the same folder.
  - **Efficient Data Storage**: BOLDigger2 saves the top 100 hits in a separate file, leading to much faster processing times. All outputs will also be saved in .hdf and .parquet format to facilitate subsequent processing for large tables.
  - **Additional Data Fields**: The top hits in BOLDigger2 will contain additional data fields, such as the number of records supporting the selected top hit, the taxonomic level used for the top hit, and all BINS the selected hit belongs to if it is a species-level hit.
  - **Additional flag**: BOLDigger2 exchanged flag 5. If the top hit is represented by multiple BINS flag 5 is used. The API verification module from BOLDigger is no longer needed.
  - **Adjusted Species-Level Threshold**: BOLDigger2 accepts hits with a similarity of >= 97% as species-level records. This decision aligns with the 3% OTU clustering threshold commonly used in DNA metabarcoding.
  - **Increased process safety**: BOLDigger2 can be stopped at any point in the processing and will simply continue where it was stopped. BOLDigger2 will no longer alter the provided FASTA file. BOLDigger2 accepts both common FASTA formats.
  - **Dynamic downloads**: BOLDigger2 will automatically adjust the number of sequences per query to the BOLD database. If the connection times out the query size will be reduced, if the request is successful, the query size will be increased.
  - **Improved error handling**: Broken records in the BOLD database are now detected and directly reported as a "BrokenRecord" in addition to "NoMatches". If the BOLD website is not accessible, BOLDigger2 will simply wait until it is up again. In addition to that, BOLDigger2 also introduces the "ImcompleteTaxonomy" hit. This is returned when all of the hits contain specials or a complete higher taxonomic level (e.g. Class / Phylum) is missing.



  BOLDigger2 requires Python version 3.10 or higher and can be easily installed using pip in any command line:

  `pip install boldigger2`

  This command will install BOLDigger2 along with all its dependencies.

  To run the identify function, use the following command:

  `boldigger2 identify PATH_TO_FASTA`

  To automate the identify function in bioinformatic pipelines, the BOLD credentials can also by passed directly as optional arguments

  `boldigger2 identify PATH_TO_FASTA -username USERNAME -password PASSWORD`

  To costumize the implemented thresholds for user-specific needs, the tresholds can be passed as an additional (ordered) argument.
  Up to 5 different thresholds can be passed for the different taxonomic levels (Species, Genus, Family, Order, Class).
  Thresholds not passed will be replaced by default, but BOLDigger2 will also inform you about this.

  `boldigger2 identify PATH_TO_FASTA -thresholds 99 97`

  Output:

  ```
  19:16:16: Default thresholds changed!
  19:16:16: Species: 99, Genus: 97, Family: 90, Order: 85, Class: 50
  19:16:16: Trying to log in.
  BOLD username:
  ```

  BOLDigger2 will prompt you for your username and password, and then it will perform the identification.

  When a new version is released, you can update BOLDigger2 by typing:

  `pip install --upgrade boldigger2`



  Buchner D, Leese F (2020) BOLDigger â€“ a Python package to identify and organise sequences with the Barcode of Life Data systems. Metabarcoding and Metagenomics 4: e53535. https://doi.org/10.3897/mbmg.4.53535




  The BOLDigger2 algorithm operates according to the following flowchart:

  1. **Log in to BOLD:**
     - Authenticate with the BOLD data systems.

  2. **Generate Download Links for Species-Level Barcodes:**
     - Generate the download links for the species-level barcode database for a batch of sequences.

  3. **Download Top 100 Hits:**
     - Retrieve the download links from the previous step.
     - Download the top 100 hits for each link.
     - Save the results to an HDF storage with the key `"top_100_hits_unsorted"`.
     - Continue until all sequences are identified.

  4. **Identify Sequences Without Species-Level Hits:**
     - Read the unsorted top 100 hits.
     - Identify sequences that did not yield a species-level hit.

  5. **Generate Download Links for All Records:**
     - Generate download links for a batch of sequences without species-level hits for the "all records on BOLD" database.

  6. **Download Top 100 Hits for All Records:**
     - Retrieve the download links from the previous step.
     - Download the top 100 hits for each link.
     - Save the results to an HDF storage with the key `"top_100_hits_unsorted"`.
     - Continue until all sequences are identified.

  7. **Sort and Save Top Hits:**
     - Read all top 100 hits.
     - Remove duplicate entries.
     - Sort the hits in the same order as in the FASTA file.
     - Identify all public records and trigger the additional data download.
     - Save them in the HDF storage with the key `"top_100_hits_sorted"`.

  8. **Save Additional Data:**
     - Save the hits including additional data to the HDF storage with the key `"top_100_hits_additional_data"`.

  9. **Export Additional Data to Excel:**
     - Save the additional data in Excel format.
     - Split the data into tables of 1,000,000 lines each.

  10. **Calculate and Save Top Hits:**
      - Calculate the top hit for each sequence.
      - Save the top hits in both Excel format (`identification_result.xlsx`) and Parquet format (`identification_result.parquet.snappy`) for fast further processing.

  ![how_it_works drawio](https://github.com/user-attachments/assets/f68dbb11-8ea8-45a9-96a3-8dba107ca5be)





  Different thresholds (97%: species level, 95%: genus level, 90%: family level, 85%: order level, <85% and >= 50: class level) for the taxonomic levels are used to find the best fitting hit. After determining the threshold for all hits the most common hit above the threshold will be selected. Note that for all hits below the threshold, the taxonomic resolution will be adjusted accordingly (e.g. for a 96% hit the species-level information will be discarded, and genus-level information will be used as the lowest taxonomic level).

  The BOLDigger2 algorithm functions as follows:

  1. **Identify Maximum Similarity**: Find the maximum similarity value among the top 100 hits currently under consideration.

  2. **Set Threshold**: Set the threshold to this maximum similarity level. Remove all hits with a similarity below this threshold. For example, if the highest hit has a similarity of 100%, the threshold will be set to 97%, and all hits below this threshold will be removed temporarily.

  3. **Classification and Sorting**: Count all individual classifications and sort them by abundance.

  4. **Filter Missing Data**: Drop all classifications that contain missing data. For instance, if the most common hit is "Arthropoda --> Insecta" with a similarity of 100% but missing values for Order, Family, Genus, and Species.

  5. **Identify Common Hit**: Look for the most common hit that has no missing values.

  6. **Return Hit**: If a hit with no missing values is found, return that hit.

  7. **Threshold Adjustment**: If no hit with no missing values is found, increase the threshold to the next higher level and repeat the process until a hit is found.




  BOLDigger2 employs a flagging system to highlight certain conditions, indicating a degree of uncertainty in the selected hit. Currently, there are five flags implemented, which may be updated as needed:

  1. **Reverse BIN Taxonomy**: This flag is raised if all of the top 100 hits representing the selected match utilize reverse BIN taxonomy. Reverse BIN taxonomy assigns species names to deposited sequences on BOLD that lack species information, potentially introducing uncertainty.

  2. **Differing Taxonomic Information**: If there are two or more entries with differing taxonomic information above the selected threshold (e.g., two species above 97%), this flag is triggered, suggesting potential discrepancies.

  3. **Private or Early-Release Data**: If all of the top 100 hits representing the top hit are private or early-release hits, this flag is raised, indicating limited accessibility to data.

  4. **Unique Hit**: This flag indicates that the top hit result represents a unique hit among the top 100 hits, potentially requiring further scrutiny.

  5. **Multiple BINs**: If the selected species-level hit is composed of more than one BIN, this flag is raised, suggesting potential complexities in taxonomic assignment.

  Given the presence of these flags, it is advisable to conduct a closer examination of all flagged hits to better understand and address any uncertainties in the selected hit.


pkgId: 50ec5a8dee8004fc04833b4dfc435902653ab129448c2bffd312f8658ca73166
name: python-boldigger3
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: A python package to query different databases of boldsystems.org v5!
url: https://github.com/DominikBuchner/BOLDigger3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boldigger3-1.2.4-1.src.rpm
checksum_type: sha256
description:
  ![BOLDigger3](https://github.com/user-attachments/assets/99606be9-8ae1-4e90-a5d5-4a6a3311f48c)


  [![Downloads](https://pepy.tech/badge/boldigger3)](https://pepy.tech/project/boldigger3)

  A Python program to query .fasta files against the databases of www.boldsystems.org v5!


  DNA metabarcoding datasets often comprise hundreds of Operational Taxonomic Units (OTUs), requiring querying against databases for taxonomic assignment. The Barcode of Life Data system (BOLD) is a widely used database for this purpose among biologists. However, BOLD's online platform limits users to identifying batches of only 1000, 200 or 100  (depending on operating mode) sequences at a time.

  BOLDigger3, the successor to BOLDigger2 and BOLDigger, aims to overcome these limitations. As a pure Python program, BOLDigger3 offers:

  - Automated access to BOLD's identification engine
  - Downloading of additional metadata for each hit
  - Selection of the best-fitting hit from the returned results



  **BOLDigger3** is an automated tool designed for DNA sequence identification through **BOLDSystems v5**, supporting integration into bioinformatics pipelines with enhanced functionality and performance. With BOLDigger3, users can identify up to **10,000 sequences per hour** without the need for credentials, using an optimized data storage and queuing system that improves speed and process safety.



  - **Unified Function**: BOLDigger3 consolidates all actions into a single function, `identify`, which automatically performs identification, additional data downloading, and top-hit selection, making it easier to integrate into pipelines.
  - **Enhanced Database Accessibility**: Users have access to all databases offered by **BOLDSystems v5** and can select from three different operating modes.
  - **Improved Speeds**: Depending on the operating mode, BOLDigger3 can identify up to **10,000 sequences per hour**, significantly faster than BOLDigger2.
  - **No Password Required**: Users no longer need credentials to perform identificationsâ€”just select the FASTA file, database, and operating mode to start.
  - **Streamlined Data Storage**: Data is stored in an **HDF Store** for faster processing, with final outputs available in `.xlsx` and `.parquet` formats.
  - **Process Safety**: BOLDigger3 can resume interrupted executions, continuing exactly where it left off.
  - **Dynamic Queuing**: The tool automatically manages request queuing based on the selected operating mode.



  - **Identify Sequences Automatically**: Run DNA sequence identifications with a single command.
  - **Flexible Database Options**: Access to all BOLDSystems v5 databases with user-selected operating modes.
  - **High-Performance Processing**: Up to 10,000 identifications per hour, depending on settings.
  - **Robust Storage**: Data stored in HDF format for efficient processing; results in `.xlsx` and `.parquet`.
  - **User-Friendly**: No credentials needed for use.



  BOLDigger3 requires Python version 3.10 or higher and can be easily installed using pip in any command line:

  `pip install boldigger3`

  This command will install BOLDigger3 along with all its dependencies.
  BOLDigger3 uses the Python package ```playwright```, which needs a separate installation prior to first execution:

  `playwright install`

  **FOR BOLDigger2 USERS:**
  BOLDigger2 used requests-html which relied on an old version of pyppeteer. This may lead to conflicts with playwright.
  Additionally, don't forget to uninstall boldigger/boldigger2
  To solve:

  ```
  pip uninstall pyppeteer
  pip uninstall boldigger
  pip uninstall boldigger2
  pip install --upgrade pyee
  ```

  To run the ```identify``` function, use the following command:

  `boldigger3 identify PATH_TO_FASTA --db DATABASE_NR --mode OPERATING MODE`



  The ```--db``` is a number between 1 and 7 corresponding to the seven databases BOLD v5 currently offers:

  1: **ANIMAL LIBRARY (PUBLIC)**
  2: **ANIMAL SPECIES-LEVEL LIBRARY (PUBLIC + PRIVATE)**
  3: **ANIMAL LIBRARY (PUBLIC+PRIVATE)**
  4: **VALIDATED CANADIAN ARTHROPOD LIBRARY**
  5: **PLANT LIBRARY (PUBLIC)**
  6: **FUNGI LIBRARY (PUBLIC)**
  7: **ANIMAL SECONDARY MARKERS (PUBLIC)**



  The ```--mode``` is a number between 1 and the corresponding to the 3 operating modes BOLD v5 currently offers:

  1: **Rapid Species Search**
  2: **Genus and Species Search**
  3: **Exhaustive Search**

  To customize the implemented thresholds for user-specific needs, the thresholds can be passed as an additional (ordered) argument. Up to five different thresholds can be passed for the different taxonomic levels (Species, Genus, Family, Order, Class). Thresholds not passed will be replaced by default, but BOLDigger3 will also inform you about this:

  `boldigger3 identify PATH_TO_FASTA --db DATABASE_NR --mode OPERATING MODE --thresholds 99 97`

  Output:

  ```
  19:16:16: Default thresholds changed!
  19:16:16: Species: 99, Genus: 97, Family: 90, Order: 85
  ```

  When a new version is released, you can update BOLDigger3 by typing:

  `pip install --upgrade boldigger3`



  Buchner D, Leese F (2020) BOLDigger â€“ a Python package to identify and organise sequences with the Barcode of Life Data systems. Metabarcoding and Metagenomics 4: e53535. https://doi.org/10.3897/mbmg.4.53535




  The BOLDigger3 algorithm operates as follows:

  1. **Split the FASTA**: The input FASTA file is divided into chunks that fit the limits of the selected operating mode of the identification engine.

  2. **Queue the Chunks**: These chunks are then queued in the identification engine for processing.

  3. **Check for Results**: The algorithm periodically checks if any results can be downloaded.

  4. **Data Download**: Once results are available, the data is downloaded.

  5. **Data Validation**: The algorithm ensures that all data has been correctly downloaded.

  6. **Retrieve Additional Data**: Additional data is obtained via the API.

  7. **Select Top Hit**: Finally, the algorithm selects the top hit backed by the most database entries for the final output.



  Different thresholds (97%: species level, 95%: genus level, 90%: family level, 85%: order level) for the taxonomic levels are used to find the best fitting hit. After determining the threshold for all hits the most common hit above the threshold will be selected. Note that for all hits below the threshold, the taxonomic resolution will be adjusted accordingly (e.g. for a 96% hit the species-level information will be discarded, and genus-level information will be used as the lowest taxonomic level).

  The BOLDigger3 algorithm functions as follows:

  1. **Identify Maximum Similarity**: Find the maximum similarity value among the top 100 hits currently under consideration.

  2. **Set Threshold**: Set the threshold to this maximum similarity level. Remove all hits with a similarity below this threshold. For example, if the highest hit has a similarity of 100%, the threshold will be set to 97%, and all hits below this threshold will be removed temporarily.

  3. **Classification and Sorting**: Count all individual classifications and sort them by abundance.

  4. **Filter Missing Data**: Drop all classifications that contain missing data. For instance, if the most common hit is "Arthropoda --> Insecta" with a similarity of 100% but missing values for Order, Family, Genus, and Species.

  5. **Identify Common Hit**: Look for the most common hit that has no missing values.

  6. **Return Hit**: If a hit with no missing values is found, return that hit.

  7. **Threshold Adjustment**: If no hit with no missing values is found, increase the threshold to the next higher level and repeat the process until a hit is found.




  BOLDigger3 employs a flagging system to highlight certain conditions, indicating a degree of uncertainty in the selected hit. Currently, there are five flags implemented, which may be updated as needed:

  1. **Reverse BIN Taxonomy**: This flag is raised if all of the top 100 hits representing the selected match utilize reverse BIN taxonomy. Reverse BIN taxonomy assigns species names to deposited sequences on BOLD that lack species information, potentially introducing uncertainty.

  2. **Differing Taxonomic Information**: If there are two or more entries with differing taxonomic information above the selected threshold (e.g., two species above 97%), this flag is triggered, suggesting potential discrepancies.

  3. **Private Data**: If all of the top 100 hits representing the top hit are private hits, this flag is raised, indicating limited accessibility to data.

  4. **Unique Hit**: This flag indicates that the top hit result represents a unique hit among the top 100 hits, potentially requiring further scrutiny.

  5. **Multiple BINs**: If the selected species-level hit is composed of more than one BIN, this flag is raised, suggesting potential complexities in taxonomic assignment.

  Given the presence of these flags, it is advisable to conduct a closer examination of all flagged hits to better understand and address any uncertainties in the selected hit.


pkgId: bb46c9d465b80815d799ef6b438e64fc66b4c1d5b00dcdfc9f3cf330a0bba6a1
name: python-bolero-process
arch: src
version: 0.0.20
epoch: 0
release: 1
summary: Data preprocessing for bolero package
url: https://pypi.org/project/bolero-process/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bolero-process-0.0.20-1.src.rpm
checksum_type: sha256
description:
  [![Tests][badge-tests]][link-tests]
  [![Documentation][badge-docs]][link-docs]

  [badge-tests]: https://img.shields.io/github/actions/workflow/status/lhqing/bolero-process/test.yaml?branch=main
  [link-tests]: https://github.com/lhqing/bolero-process/actions/workflows/test.yml
  [badge-docs]: https://img.shields.io/readthedocs/bolero-process

  Data preprocessing for bolero package



  Please refer to the [documentation][link-docs]. In particular, the

  -   [API documentation][link-api].



  You need to have Python 3.9 or newer installed on your system. If you don't have
  Python installed, we recommend installing [Mambaforge](https://github.com/conda-forge/miniforge#mambaforge).

  There are several alternative options to install bolero-process:

  <!--
  1) Install the latest release of `bolero-process` from `PyPI <https://pypi.org/project/bolero-process/>`_:

  ```bash
  pip install bolero-process
  ```
  -->

  1. Install the latest development version:

  ```bash
  pip install git+https://github.com/lhqing/bolero-process.git@main
  ```



  See the [changelog][changelog].



  For questions and help requests, you can reach out in the [scverse discourse][scverse-discourse].
  If you found a bug, please use the [issue tracker][issue-tracker].



  > t.b.a

  [scverse-discourse]: https://discourse.scverse.org/
  [issue-tracker]: https://github.com/lhqing/bolero-process/issues
  [changelog]: https://bolero-process.readthedocs.io/latest/changelog.html
  [link-docs]: https://bolero-process.readthedocs.io
  [link-api]: https://bolero-process.readthedocs.io/latest/api.html

rpm_license:
  MIT License  Copyright (c) 2024, Hanqing Liu  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: 3113927299f2a24f0bbde63e80e3030141a548bfb4804d0969efbe862050c381
name: python-bolna
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bolna/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bolna-0.9.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
  </h1>
  <p align="center">
    <p align="center"><b>End-to-end open-source voice agents platform</b>: Quickly build voice firsts conversational assistants through a json. </p>
  </p>

  <h4 align="center">
    <a href="https://discord.gg/59kQWGgnm8">Discord</a> |
    <a href="https://docs.bolna.dev">Docs</a> |
    <a href="https://bolna.dev">Website</a>
  </h4>

  <h4 align="center">
    <a href="https://discord.gg/59kQWGgnm8">
        <img src="https://img.shields.io/static/v1?label=Chat%20on&message=Discord&color=blue&logo=Discord&style=flat-square" alt="Discord">
    </a>
    <a href="https://github.com/bolna-ai/bolna/blob/main/LICENSE">
      <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="Bolna is released under the MIT license." />
    </a>
    <a href="https://github.com/bolna-ai/bolna/blob/main/CONTRIBUTING.md">
      <img src="https://img.shields.io/badge/PRs-Welcome-brightgreen" alt="PRs welcome!" />
    </a>
  </h4>

  > [!NOTE]
  > We are actively looking for maintainers.



  **[Bolna](https://bolna.dev)** is the end-to-end open source production ready framework for quickly building LLM based voice driven conversational applications.


  https://github.com/bolna-ai/bolna/assets/1313096/2237f64f-1c5b-4723-b7e7-d11466e9b226



  This repository contains the entire orchestration platform to build voice AI applications. It technically orchestrates voice conversations using combination of different ASR+LLM+TTS providers and models over websockets.



  Bolna helps you create AI Voice Agents which can be instructed to do tasks beginning with:

  1. Orchestration platform (this open source repository)
  2. Hosted APIs (https://docs.bolna.dev/api-reference/introduction) built on top of this orchestration platform [currently closed source]
  3. No-code UI playground at https://playground.bolna.dev/ using the hosted APIs + tailwind CSS [currently closed source]



  1. Any integration, enhancement or feature initially lands on this open source package since it form the backbone of our APIs and dashboard
  2. Post that we expose APIs or make changes to existing APIs as required for the same
  3. Thirdly, we push it to the UI dashboard

  ```mermaid
  graph LR;
      A[Bolna open source] -->B[Hosted APIs];
      B[Hosted APIs] --> C[Playground]
  ```


  1. Initiating a phone call using telephony providers like `Twilio`, `Plivo`, `Exotel` (coming soon), `Vonage` (coming soon) etc.
  2. Transcribing the conversations using `Deepgram`, etc.
  3. Using LLMs like `OpenAI`, `Llama`, `Cohere`, `Mistral`,  etc to handle conversations
  4. Synthesizing LLM responses back to telephony using `AWS Polly`, `ElevenLabs`, `Deepgram`, `OpenAI`, `Azure`, `Cartesia`, `Smallest` etc.


  Refer to the [docs](https://docs.bolna.dev/providers) for a deepdive into all supported providers.



  A basic local setup includes usage of [Twilio](local_setup/telephony_server/twilio_api_server.py) or [Plivo](local_setup/telephony_server/plivo_api_server.py) for telephony. We have dockerized the setup in `local_setup/`. One will need to populate an environment `.env` file from `.env.sample`.

  The setup consists of four containers:

  1. Telephony web server:
     * Choosing Twilio: for initiating the calls one will need to set up a [Twilio account](https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account)
     * Choosing Plivo: for initiating the calls one will need to set up a [Plivo account](https://www.plivo.com/)
  2. Bolna server: for creating and handling agents
  3. `ngrok`: for tunneling. One will need to add the `authtoken` to `ngrok-config.yml`
  4. `redis`: for persisting agents & prompt data

  Use docker to build the images using `.env` file as the environment file and run them locally
  1. `docker-compose build --no-cache bolna-app <twilio-app | plivo-app>`: rebuild images
  2. `docker-compose up bolna-app <twilio-app | plivo-app>`: run the build images

  Once the docker containers are up, you can now start to create your agents and instruct them to initiate calls.



  Go to the [Bolna wiki](https://github.com/bolna-ai/bolna/wiki) to try out sample agents.



  You can populate the `.env` file to use your own keys for providers.

  <details>

  <summary>ASR Providers</summary><br>
  These are the current supported ASRs Providers:

  | Provider     | Environment variable to be added in `.env` file |
  |--------------|-------------------------------------------------|
  | Deepgram     | `DEEPGRAM_AUTH_TOKEN`                           |

  </details>
  &nbsp;<br>

  <details>
  <summary>LLM Providers</summary><br>
  Bolna uses LiteLLM package to support multiple LLM integrations.

  These are the current supported LLM Provider Family:
  https://github.com/bolna-ai/bolna/blob/477e08d6800dbf02931abeeea883d78451b7d7e2/bolna/providers.py#L29-L44

  For LiteLLM based LLMs, add either of the following to the `.env` file depending on your use-case:<br><br>
  `LITELLM_MODEL_API_KEY`: API Key of the LLM<br>
  `LITELLM_MODEL_API_BASE`: URL of the hosted LLM<br>
  `LITELLM_MODEL_API_VERSION`: API VERSION for LLMs like Azure

  For LLMs hosted via VLLM, add the following to the `.env` file:<br>
  `VLLM_SERVER_BASE_URL`: URL of the hosted LLM using VLLM

  </details>
  &nbsp;<br>

  <details>

  <summary>TTS Providers</summary><br>
  These are the current supported TTS Providers:
  https://github.com/bolna-ai/bolna/blob/c8a0d1428793d4df29133119e354bc2f85a7ca76/bolna/providers.py#L7-L14

  | Provider   | Environment variable to be added in `.env` file  |
  |------------|--------------------------------------------------|
  | AWS Polly  | Accessed from system wide credentials via ~/.aws |
  | Elevenlabs | `ELEVENLABS_API_KEY`                             |
  | OpenAI     | `OPENAI_API_KEY`                                 |
  | Deepgram   | `DEEPGRAM_AUTH_TOKEN`                            |
  | Cartesia   | `CARTESIA_API_KEY`                            |
  | Smallest   | `SMALLEST_API_KEY`                            |

  </details>
  &nbsp;<br>

  <details>

  <summary>Telephony Providers</summary><br>
  These are the current supported Telephony Providers:

  | Provider | Environment variable to be added in `.env` file                                                                                                                    |
  |----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | Twilio   | `TWILIO_ACCOUNT_SID`, `TWILIO_AUTH_TOKEN`, `TWILIO_PHONE_NUMBER`|
  | Plivo    | `PLIVO_AUTH_ID`, `PLIVO_AUTH_TOKEN`, `PLIVO_PHONE_NUMBER`|

  </details>


  **We have in the past tried to maintain both the open source and the hosted solution (via APIs and a UI dashboard)**.

  We have fluctuated b/w maintaining this repository purely from a point of time crunch and not interest.

  Currently, we are continuing to maintain it for the community and improving the adoption of Voice AI.

  Though the repository is completely open source, you can connect with us if interested in managed hosted offerings or more customized solutions.
  <a href="https://calendly.com/bolna/30min"><img alt="Schedule a meeting" src="https://cdn.cookielaw.org/logos/122ecfc3-4694-42f1-863f-2db42d1b1e68/0bcbbcf4-9b83-4684-ba59-bc913c0d5905/c21bea90-f4f1-43d1-8118-8938bbb27a9d/logo.png" /></a>


  In case you wish to extend and add some other Telephony like Vonage, Telnyx, etc. following the guidelines below:
  1. Make sure bi-directional streaming is supported by the Telephony provider
  2. Add the telephony-specific input handler file in [input_handlers/telephony_providers](https://github.com/bolna-ai/bolna/tree/master/bolna/input_handlers/telephony_providers) writing custom functions extending from the [telephony.py](https://github.com/bolna-ai/bolna/blob/master/bolna/input_handlers/telephony.py) class
     1. This file will mainly contain how different types of event packets are being ingested from the telephony provider
  3. Add telephony-specific output handler file in [output_handlers/telephony_providers](https://github.com/bolna-ai/bolna/tree/master/bolna/output_handlers/telephony_providers) writing custom functions extending from the [telephony.py](https://github.com/bolna-ai/bolna/blob/master/bolna/output_handlers/telephony.py) class
     1. This mainly concerns converting audio from the synthesizer class to a supported audio format and streaming it over the websocket provided by the telephony provider
  4. Lastly, you'll have to write a dedicated server like the example [twilio_api_server.py](https://github.com/bolna-ai/bolna/blob/master/local_setup/telephony_server/twilio_api_server.py) provided in [local_setup](https://github.com/bolna-ai/bolna/blob/master/local_setup/telephony_server) to initiate calls over websockets.



  We love all types of contributions: whether big or small helping in improving this community resource.

  1. There are a number of [open issues present](https://github.com/bolna-ai/bolna/issues) which can be good ones to start with
  2. If you have suggestions for enhancements, wish to contribute a simple fix such as correcting a typo, or want to address an apparent bug, please feel free to initiate a new issue or submit a pull request
  2. If you're contemplating a larger change or addition to this repository, be it in terms of its structure or the features, kindly begin by creating a new issue [open a new issue :octocat:](https://github.com/bolna-ai/bolna/issues/new) and outline your proposed changes. This will allow us to engage in a discussion before you dedicate a significant amount of time or effort. Your cooperation and understanding are appreciated

rpm_license:
  Copyright (c) 2023 Bolna  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: 1493f03298cdd4a2cfd86acc0bae05ff0486764462a92b6f32a97e7eee205689
name: python-bolt11
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: A library for encoding and decoding BOLT11 payment requests.
url: https://github.com/lnbits/bolt11
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bolt11-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![github-tests-badge]][github-tests]
  [![github-mypy-badge]][github-mypy]
  [![codecov-badge]][codecov]
  [![pypi-badge]][pypi]
  [![pypi-versions-badge]][pypi]
  [![license-badge]](LICENSE)
  This is an implementation of the Lightning BOLT11 specification,
  based on previous work by [Rusty Russell][rusty], the [Electrum Wallet team][electrum],
  and the LNbits bolt11 helpers created by [@fiatjaf][fiatjaf].
  [github-tests]: https://github.com/lnbits/bolt11/actions?query=workflow%3A%22tests%22
  [github-tests-badge]: https://github.com/lnbits/bolt11/workflows/tests/badge.svg
  [github-mypy]: https://github.com/lnbits/bolt11/actions?query=workflow%3A%22mypy%22
  [github-mypy-badge]: https://github.com/lnbits/bolt11/workflows/mypy/badge.svg
  [codecov]: https://codecov.io/gh/lnbits/bolt11
  [codecov-badge]: https://codecov.io/gh/lnbits/bolt11/branch/master/graph/badge.svg
  [pypi]: https://pypi.org/project/bolt11/
  [pypi-badge]: https://badge.fury.io/py/bolt11.svg
  [pypi-versions-badge]: https://img.shields.io/pypi/pyversions/bolt11.svg
  [license-badge]: https://img.shields.io/badge/license-MIT-blue.svg
  [electrum]: https://github.com/spesmilo/electrum
  [fiatjaf]: https://github.com/fiatjaf
  [rusty]: https://github.com/rustyrussell/lightning-payencode

  * [Bolt11 Spec](https://github.com/lightning/bolts/blob/master/11-payment-encoding.md )
  * [bolt11.org](https://www.bolt11.org/)
  * [lightningdecoder](https://lightningdecoder.com/)

  ```console
  $ git clone https://github.com/lnbits/bolt11
  $ cd bolt11
  $ poetry install
  ```

  ```console
  $ poetry run bolt11 --help
  $ poetry run bolt11 decode
  ```

  ```console
  $ make
  ```

  ```console
  $ poetry run pre-commit install
  ```

  ```console
  $ poetry run bolt11 --help
  ```

  ```
  $ poetry run bolt11 decode lnbc20m1pvjluez.....
  {
    "currency": "bc",
    "amount": 2000000000,
    "timestamp": 1496314658,
    "signature": "6a6586db4e8f6d40e3a5bb92e4df5110c627e9ce493af237e20a046b4e86ea200178c59564ecf892f33a9558bf041b6ad2cb8292d7a6c351fbb7f2ae2d16b54e",
    "description_hash": "3925b6f67e2c340036ed12093dd44e0368df1b6ea26c53dbe4811f58fd5db8c1",
    "features": {
      "var_onion_optin": "required",
      "payment_secret": "required"
    },
    "fallback": "1RustyRX2oai4EYYDpQGWvEL62BBGqN9T",
    "route_hints": [
      {
        "public_key": "029e03a901b85534ff1e92c43c74431f7ce72046060fcf7a95c37e148f78c77255",
        "short_channel_id": "66051x263430x1800",
        "base_fee": 1,
        "ppm_fee": 20,
        "cltv_expiry_delta": 3
      },
      {
        "public_key": "039e03a901b85534ff1e92c43c74431f7ce72046060fcf7a95c37e148f78c77255",
        "short_channel_id": "197637x395016x2314",
        "base_fee": 2,
        "ppm_fee": 30,
        "cltv_expiry_delta": 4
      }
    ],
    "min_final_cltv_expiry": 9,
    "payment_hash": "0001020304050607080900010203040506070809000102030405060708090102",
    "payment_secret": "1111111111111111111111111111111111111111111111111111111111111111",
    "payee": "03e7156ae33b0a208d0744199163177e909e80176e55d97a2f221ede0f934dd9ad"
  }
  ```

  ```
  $ poetry run bolt11 encode '{
    "currency": "bc",
    "amount_msat": 1000,
    "date": 1590000000,
    "payment_hash": "0001020304050607080900010203040506070809000102030405060708090102",
    "payment_secret": "1111111111111111111111111111111111111111111111111111111111111111",
    "description": "description"
  }' e126f68f7eafcc8b74f54d269fe206be715000f94dac067d1c04a8ca3b2db734


pkgId: 77b80e3db9351e9543d80df33758b8e2ec02f1be653ae07b05948e310a47cff1
name: python-boltdb
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: python port of boltdb
url: https://github.com/qingyunha/pybolt
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boltdb-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A Python port of [Bolt][bolt] key/value store.

  [bolt]: https://github.com/boltdb/bolt




  ``` console
  $ pip install boltdb
  ```




  see [test\_bucket.py](./tests/test_bucket.py)


pkgId: 526d5ad5d81b01a8f344b2992ff30edae71d3b9d1e772fc36ab3007da1c20a96
name: python-bolton-ion
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: I/O ninja (ION)... Utilities related to I/O that we find useful.
url: https://github.com/python-boltons/ion
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bolton-ion-0.1.0-1.src.rpm
checksum_type: sha256
description:
  **I/O ninja (ION)... Utilities related to I/O that we find useful.**

  _project status badges:_

  [![CI Workflow](https://github.com/python-boltons/ion/actions/workflows/ci.yml/badge.svg)](https://github.com/python-boltons/ion/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/python-boltons/ion/branch/master/graph/badge.svg)](https://codecov.io/gh/python-boltons/ion)
  [![Documentation Status](https://readthedocs.org/projects/bolton-ion/badge/?version=latest)](https://bolton-ion.readthedocs.io/en/latest/?badge=latest)
  [![Package Health](https://snyk.io/advisor/python/bolton-ion/badge.svg)](https://snyk.io/advisor/python/bolton-ion)

  _version badges:_

  [![Project Version](https://img.shields.io/pypi/v/bolton-ion)](https://pypi.org/project/bolton-ion/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bolton-ion)](https://pypi.org/project/bolton-ion/)
  [![Cookiecutter: cc-python](https://img.shields.io/static/v1?label=cc-python&message=2021.12.22&color=d4aa00&logo=cookiecutter&logoColor=d4aa00)](https://github.com/python-boltons/cc-python)
  [![Docker: pythonboltons/main](https://img.shields.io/static/v1?label=pythonboltons%20%2F%20main&message=2021.12.22&color=8ec4ad&logo=docker&logoColor=8ec4ad)](https://github.com/python-boltons/docker-python)




  To install `bolton-ion` using [pip][9], run the following
  commands in your terminal:

  ``` shell
  python3 -m pip install --user bolton-ion  # install ion
  ```

  If you don't have pip installed, this [Python installation guide][10] can guide
  you through the process.




  * [API Reference][3]: A developer's reference of the API exposed by this
    project.
  * [cc-python][4]: The [cookiecutter][5] that was used to generate this project.
    Changes made to this cookiecutter are periodically synced with this project
    using [cruft][12].
  * [CHANGELOG.md][2]: We use this file to document all notable changes made to
    this project.
  * [CONTRIBUTING.md][7]: This document contains guidelines for developers
    interested in contributing to this project.
  * [Create a New Issue][13]: Create a new GitHub issue for this project.
  * [Documentation][1]: This project's full documentation.


  [1]: https://bolton-ion.readthedocs.io/en/latest
  [2]: https://github.com/python-boltons/ion/blob/master/CHANGELOG.md
  [3]: https://bolton-ion.readthedocs.io/en/latest/modules.html
  [4]: https://github.com/python-boltons/cc-python
  [5]: https://github.com/cookiecutter/cookiecutter
  [6]: https://docs.readthedocs.io/en/stable/
  [7]: https://github.com/python-boltons/ion/blob/master/CONTRIBUTING.md
  [8]: https://github.com/python-boltons/ion
  [9]: https://pip.pypa.io
  [10]: http://docs.python-guide.org/en/latest/starting/installation/
  [11]: https://github.com/pypa/pipx
  [12]: https://github.com/cruft/cruft
  [13]: https://github.com/python-boltons/ion/issues/new/choose


pkgId: 7376e6d00b4ef16c4ecb87c79d71c54d5f85d4baf8798da377e9e8c306f53153
name: python-bolton-metaman
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://github.com/python-boltons/metaman
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bolton-metaman-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  metadata manager (METAMAN)... Makes use of Python's dynamic nature to inspect a program's internals.

description:
  **metadata manager (METAMAN)... Makes use of Python's dynamic nature to inspect a program's internals.**

  _project status badges:_

  [![CI Workflow](https://github.com/python-boltons/metaman/actions/workflows/ci.yml/badge.svg)](https://github.com/python-boltons/metaman/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/python-boltons/metaman/branch/master/graph/badge.svg)](https://codecov.io/gh/python-boltons/metaman)
  [![Documentation Status](https://readthedocs.org/projects/bolton-metaman/badge/?version=latest)](https://bolton-metaman.readthedocs.io/en/latest/?badge=latest)
  [![Package Health](https://snyk.io/advisor/python/bolton-metaman/badge.svg)](https://snyk.io/advisor/python/bolton-metaman)

  _version badges:_

  [![Project Version](https://img.shields.io/pypi/v/bolton-metaman)](https://pypi.org/project/bolton-metaman/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bolton-metaman)](https://pypi.org/project/bolton-metaman/)
  [![Cookiecutter: cc-python](https://img.shields.io/static/v1?label=cc-python&message=2022.01.04&color=d4aa00&logo=cookiecutter&logoColor=d4aa00)](https://github.com/python-boltons/cc-python)
  [![Docker: pythonboltons/main](https://img.shields.io/static/v1?label=pythonboltons%20%2F%20main&message=2021.12.22&color=8ec4ad&logo=docker&logoColor=8ec4ad)](https://github.com/python-boltons/docker-python)




  To install `metaman` using [pip][9], run the following
  commands in your terminal:

  ``` shell
  python3 -m pip install --user bolton-metaman  # install metaman
  ```

  If you don't have pip installed, this [Python installation guide][10] can guide
  you through the process.

  <!-- [[[[[kooky.cog
  from pathlib import Path

  lines = Path("./docs/design/design.md").read_text().split("\n")
  if any(L.strip() for L in lines):
      fixed_lines = [L.replace("(.", "(./docs/design") if L.startswith("![") else L for L in lines]
      print("## Design Diagrams\n")
      print("\n".join(fixed_lines))
  ]]]]] -->
  <!-- [[[[[end]]]]] -->




  * [API Reference][3]: A developer's reference of the API exposed by this
    project.
  * [cc-python][4]: The [cookiecutter][5] that was used to generate this project.
    Changes made to this cookiecutter are periodically synced with this project
    using [cruft][12].
  * [CHANGELOG.md][2]: We use this file to document all notable changes made to
    this project.
  * [CONTRIBUTING.md][7]: This document contains guidelines for developers
    interested in contributing to this project.
  * [Create a New Issue][13]: Create a new GitHub issue for this project.
  * [Documentation][1]: This project's full documentation.


  [1]: https://bolton-metaman.readthedocs.io/en/latest
  [2]: https://github.com/python-boltons/metaman/blob/master/CHANGELOG.md
  [3]: https://bolton-metaman.readthedocs.io/en/latest/modules.html
  [4]: https://github.com/python-boltons/cc-python
  [5]: https://github.com/cookiecutter/cookiecutter
  [6]: https://docs.readthedocs.io/en/stable/
  [7]: https://github.com/python-boltons/metaman/blob/master/CONTRIBUTING.md
  [8]: https://github.com/python-boltons/metaman
  [9]: https://pip.pypa.io
  [10]: http://docs.python-guide.org/en/latest/starting/installation/
  [11]: https://github.com/pypa/pipx
  [12]: https://github.com/cruft/cruft
  [13]: https://github.com/python-boltons/metaman/issues/new/choose


pkgId: 6117b186e6c0bfbc297d90a0fe59b083f872ffcc0cee5ea6611190e6f9de251c
name: python-bolton-typist
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Typing utilities we wish were in the standard library.
url: https://github.com/python-boltons/typist
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bolton-typist-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **Typing utilities we wish were in the standard library.**

  _project status badges:_

  [![CI Workflow](https://github.com/python-boltons/typist/actions/workflows/ci.yml/badge.svg)](https://github.com/python-boltons/typist/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/python-boltons/typist/branch/master/graph/badge.svg)](https://codecov.io/gh/python-boltons/typist)
  [![Documentation Status](https://readthedocs.org/projects/bolton-typist/badge/?version=latest)](https://bolton-typist.readthedocs.io/en/latest/?badge=latest)
  [![Package Health](https://snyk.io/advisor/python/bolton-typist/badge.svg)](https://snyk.io/advisor/python/bolton-typist)

  _version badges:_

  [![Project Version](https://img.shields.io/pypi/v/bolton-typist)](https://pypi.org/project/bolton-typist/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/bolton-typist)](https://pypi.org/project/bolton-typist/)
  [![Cookiecutter: cc-python](https://img.shields.io/static/v1?label=cc-python&message=2022.01.04&color=d4aa00&logo=cookiecutter&logoColor=d4aa00)](https://github.com/python-boltons/cc-python)
  [![Docker: pythonboltons/main](https://img.shields.io/static/v1?label=pythonboltons%20%2F%20main&message=2021.12.22&color=8ec4ad&logo=docker&logoColor=8ec4ad)](https://github.com/python-boltons/docker-python)




  To install `typist` using [pip][9], run the following
  commands in your terminal:

  ``` shell
  python3 -m pip install --user bolton-typist  # install typist
  ```

  If you don't have pip installed, this [Python installation guide][10] can guide
  you through the process.




  * [API Reference][3]: A developer's reference of the API exposed by this
    project.
  * [cc-python][4]: The [cookiecutter][5] that was used to generate this project.
    Changes made to this cookiecutter are periodically synced with this project
    using [cruft][12].
  * [CHANGELOG.md][2]: We use this file to document all notable changes made to
    this project.
  * [CONTRIBUTING.md][7]: This document contains guidelines for developers
    interested in contributing to this project.
  * [Create a New Issue][13]: Create a new GitHub issue for this project.
  * [Documentation][1]: This project's full documentation.


  [1]: https://bolton-typist.readthedocs.io/en/latest
  [2]: https://github.com/python-boltons/typist/blob/master/CHANGELOG.md
  [3]: https://bolton-typist.readthedocs.io/en/latest/modules.html
  [4]: https://github.com/python-boltons/cc-python
  [5]: https://github.com/cookiecutter/cookiecutter
  [6]: https://docs.readthedocs.io/en/stable/
  [7]: https://github.com/python-boltons/typist/blob/master/CONTRIBUTING.md
  [8]: https://github.com/python-boltons/typist
  [9]: https://pip.pypa.io
  [10]: http://docs.python-guide.org/en/latest/starting/installation/
  [11]: https://github.com/pypa/pipx
  [12]: https://github.com/cruft/cruft
  [13]: https://github.com/python-boltons/typist/issues/new/choose


pkgId: b832f55120ddd209371f76d0c29b838bbc9f6503e24e4e1836a6a546ccb7905d
name: python-boltons
arch: src
version: 24.0.0
epoch: 0
release: 1
summary: When they're not builtins, they're boltons.
url: https://github.com/mahmoud/boltons
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boltons-24.0.0-1.src.rpm
checksum_type: sha256
description:
  Functionality that should be in the standard library. Like
  builtins, but Boltons.

  Otherwise known as, "everyone's util.py," but cleaned up and
  tested.

  Contains over 250 BSD-licensed utility types and functions that can be
  used as a package or independently. `Extensively documented on Read
  the Docs <http://boltons.readthedocs.org>`_.


pkgId: eeb7f9d9acf8a9b491db0b4a0375f606c4291d5294ea7369121e6d30662fc80a
name: python-boltz
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Boltz-1
url: https://pypi.org/project/boltz/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boltz-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Boltz-1:

  Democratizing Biomolecular Interaction Modeling
  </h1>

  ![](docs/boltz1_pred_figure.png)

  Boltz-1 is an open-source model which predicts the 3D structure of proteins, RNA, DNA and small molecules; it handles modified residues, covalent ligands and glycans, as well as condition the generation on pocket residues.

  For more information about the model, see our [technical report](https://gcorso.github.io/assets/boltz1.pdf).


  Install boltz with PyPI (recommended):

  ```
  pip install boltz
  ```

  or directly from GitHub for daily updates:

  ```
  git clone https://github.com/jwohlwend/boltz.git
  cd boltz; pip install -e .
  ```
  > Note: we recommend installing boltz in a fresh python environment



  You can run inference using Boltz-1 with:

  ```
  boltz predict input_path
  ```

  Boltz currently accepts three input formats:

  1. Fasta file, for most use cases

  2. A comprehensive YAML schema, for more complex use cases

  3. A directory containing files of the above formats, for batched processing

  To see all available options: `boltz predict --help` and for more informaton on these input formats, see our [prediction instructions](docs/prediction.md).



  If you're interested in retraining the model, see our [training instructions](docs/training.md).



  We welcome external contributions and are eager to engage with the community. Connect with us on our [Slack channel](https://join.slack.com/t/boltz-community/shared_invite/zt-2uexwkemv-Tqt9E747hVkE0VOWlgOcIw) to discuss advancements, share insights, and foster collaboration around Boltz-1.



  - [x] Auto-generated MSAs using MMseqs2
  - [x] More examples
  - [ ] Support for custom paired MSA
  - [ ] Confidence model checkpoint
  - [ ] Pocket conditioning support
  - [ ] Full data processing pipeline
  - [ ] Colab notebook for inference
  - [ ] Kernel integration



  Our model and code are released under MIT License, and can be freely used for both academic and commercial purposes.




  If you use this code or the models in your research, please cite the following paper:

  ```bibtex
  @article{wohlwend2024boltz1,
    author = {Wohlwend, Jeremy and Corso, Gabriele and Passaro, Saro and Reveiz, Mateo and Leidal, Ken and Swiderski, Wojtek and Portnoi, Tally and Chinn, Itamar and Silterra, Jacob and Jaakkola, Tommi and Barzilay, Regina},
    title = {Boltz-1: Democratizing Biomolecular Interaction Modeling},
    year = {2024},
    doi = {10.1101/2024.11.19.624167},
    journal = {bioRxiv}
  }
  ```

  In addition if you use the automatic MSA generation, please cite:

  ```bibtex
  @article{mirdita2022colabfold,
    title={ColabFold: making protein folding accessible to all},
    author={Mirdita, Milot and Sch{\"u}tze, Konstantin and Moriwaki, Yoshitaka and Heo, Lim and Ovchinnikov, Sergey and Steinegger, Martin},
    journal={Nature methods},
    year={2022},
  }
  ```


pkgId: 2722ea6a44e24058ea8416e1d8b9fe39a5b48eed8daa3692add86d3a4c2b9298
name: python-boltz
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Boltz-1
url: https://pypi.org/project/boltz/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boltz-0.3.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Boltz-1:

  Democratizing Biomolecular Interaction Modeling
  </h1>

  ![](docs/boltz1_pred_figure.png)

  Boltz-1 is an open-source model which predicts the 3D structure of proteins, RNA, DNA and small molecules; it handles modified residues, covalent ligands and glycans, as well as condition the generation on pocket residues.

  For more information about the model, see our [technical report](https://doi.org/10.1101/2024.11.19.624167).


  Install boltz with PyPI (recommended):

  ```
  pip install boltz
  ```

  or directly from GitHub for daily updates:

  ```
  git clone https://github.com/jwohlwend/boltz.git
  cd boltz; pip install -e .
  ```
  > Note: we recommend installing boltz in a fresh python environment



  You can run inference using Boltz-1 with:

  ```
  boltz predict input_path
  ```

  Boltz currently accepts three input formats:

  1. Fasta file, for most use cases

  2. A comprehensive YAML schema, for more complex use cases

  3. A directory containing files of the above formats, for batched processing

  To see all available options: `boltz predict --help` and for more informaton on these input formats, see our [prediction instructions](docs/prediction.md).



  If you're interested in retraining the model, see our [training instructions](docs/training.md).



  We welcome external contributions and are eager to engage with the community. Connect with us on our [Slack channel](https://join.slack.com/t/boltz-community/shared_invite/zt-2uexwkemv-Tqt9E747hVkE0VOWlgOcIw) to discuss advancements, share insights, and foster collaboration around Boltz-1.



  - [x] Auto-generated MSAs using MMseqs2
  - [x] More examples
  - [x] Support for custom paired MSA
  - [x] Confidence model checkpoint
  - [x] Chunking for lower memory usage
  - [ ] Pocket conditioning support
  - [ ] Full data processing pipeline
  - [ ] Colab notebook for inference
  - [ ] Kernel integration



  Our model and code are released under MIT License, and can be freely used for both academic and commercial purposes.




  If you use this code or the models in your research, please cite the following paper:

  ```bibtex
  @article{wohlwend2024boltz1,
    author = {Wohlwend, Jeremy and Corso, Gabriele and Passaro, Saro and Reveiz, Mateo and Leidal, Ken and Swiderski, Wojtek and Portnoi, Tally and Chinn, Itamar and Silterra, Jacob and Jaakkola, Tommi and Barzilay, Regina},
    title = {Boltz-1: Democratizing Biomolecular Interaction Modeling},
    year = {2024},
    doi = {10.1101/2024.11.19.624167},
    journal = {bioRxiv}
  }
  ```

  In addition if you use the automatic MSA generation, please cite:

  ```bibtex
  @article{mirdita2022colabfold,
    title={ColabFold: making protein folding accessible to all},
    author={Mirdita, Milot and Sch{\"u}tze, Konstantin and Moriwaki, Yoshitaka and Heo, Lim and Ovchinnikov, Sergey and Steinegger, Martin},
    journal={Nature methods},
    year={2022},
  }
  ```


pkgId: c919aeb415456f4f0e117e6e3fb9e643f9e694609157027ef2388591fd254ed2
name: python-boltz
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Boltz-1
url: https://pypi.org/project/boltz/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boltz-0.3.2-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Boltz-1:

  Democratizing Biomolecular Interaction Modeling
  </h1>

  ![](docs/boltz1_pred_figure.png)

  Boltz-1 is the state-of-the-art open-source model that predicts the 3D structure of proteins, RNA, DNA, and small molecules; it handles modified residues, covalent ligands and glycans, as well as condition the generation on pocket residues.

  For more information about the model, see our [technical report](https://doi.org/10.1101/2024.11.19.624167).


  Install boltz with PyPI (recommended):

  ```
  pip install boltz -U
  ```

  or directly from GitHub for daily updates:

  ```
  git clone https://github.com/jwohlwend/boltz.git
  cd boltz; pip install -e .
  ```
  > Note: we recommend installing boltz in a fresh python environment



  You can run inference using Boltz-1 with:

  ```
  boltz predict input_path --use_msa_server
  ```

  Boltz currently accepts three input formats:

  1. Fasta file, for most use cases

  2. A comprehensive YAML schema, for more complex use cases

  3. A directory containing files of the above formats, for batched processing

  To see all available options: `boltz predict --help` and for more informaton on these input formats, see our [prediction instructions](docs/prediction.md).



  If you're interested in retraining the model, see our [training instructions](docs/training.md).



  We welcome external contributions and are eager to engage with the community. Connect with us on our [Slack channel](https://join.slack.com/t/boltz-community/shared_invite/zt-2uexwkemv-Tqt9E747hVkE0VOWlgOcIw) to discuss advancements, share insights, and foster collaboration around Boltz-1.



  - [x] Auto-generated MSAs using MMseqs2
  - [x] More examples
  - [x] Support for custom paired MSA
  - [x] Confidence model checkpoint
  - [x] Chunking for lower memory usage
  - [ ] Pocket conditioning support
  - [ ] Full data processing pipeline
  - [ ] Colab notebook for inference
  - [ ] Kernel integration



  Our model and code are released under MIT License, and can be freely used for both academic and commercial purposes.




  If you use this code or the models in your research, please cite the following paper:

  ```bibtex
  @article{wohlwend2024boltz1,
    author = {Wohlwend, Jeremy and Corso, Gabriele and Passaro, Saro and Reveiz, Mateo and Leidal, Ken and Swiderski, Wojtek and Portnoi, Tally and Chinn, Itamar and Silterra, Jacob and Jaakkola, Tommi and Barzilay, Regina},
    title = {Boltz-1: Democratizing Biomolecular Interaction Modeling},
    year = {2024},
    doi = {10.1101/2024.11.19.624167},
    journal = {bioRxiv}
  }
  ```

  In addition if you use the automatic MSA generation, please cite:

  ```bibtex
  @article{mirdita2022colabfold,
    title={ColabFold: making protein folding accessible to all},
    author={Mirdita, Milot and Sch{\"u}tze, Konstantin and Moriwaki, Yoshitaka and Heo, Lim and Ovchinnikov, Sergey and Steinegger, Martin},
    journal={Nature methods},
    year={2022},
  }
  ```


pkgId: 899803b63ad63aff430e6895a407ac27250317b5bddf2ff748611ade5518e840
name: python-boltz_client
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: python boltz client
url: https://boltz.exchange
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boltz_client-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Boltz Client in Python, implementing mainchain and liquid submarine swaps. Used by e.g. https://github.com/lnbits/boltz.


  ```console
  $ boltz --help
  Usage: boltz [OPTIONS] COMMAND [ARGS]...

    Python CLI of boltz-client-python, enjoy submarine swapping. :)

  Options:
    --help  Show this message and exit.

  Commands:
    calculate-swap-send-amount     calculate the amount of the invoice you...
    claim-reverse-swap             claims a reverse swap
    create-reverse-swap            create a reverse swap
    create-reverse-swap-and-claim  create a reverse swap and claim
    create-swap                    create a swap boltz will pay your...
    refund-swap                    refund a swap
    show-pairs                     show pairs of possible assets to swap
    swap-status                    get swap status retrieves the status of...
  ```
  install the latest release from [PyPI](https://pypi.org/project/boltz-client) via `pip install boltz_client`.



  ```python
  from boltz_client import BoltzClient, BoltzConfig
  config = BoltzConfig() # default config
  client = BoltzClient(config, "BTC/BTC")
  ```

  ```python
  pr = create_lightning_invoice(100000) # example function to create a lightning invoice
  refund_privkey_wif, swap = client.create_swap(pr)
  print(f"pay this amount: {swap.expectedAmount}")
  print(f"to this address: {swap.address}")

  ```
  if swap fails you can refund like this
  ```python

  onchain_address = create_onchain_address()
  txid = await client.refund_swap(
      boltz_id=swap.id,
      privkey_wif=refund_privkey_wif,
      lockup_address=swap.address,
      receive_address=onchain_address,
      redeem_script_hex=swap.redeemScript,
      timeout_block_height=swap.timeoutBlockHeight,
  )
  ```


  ```python
  claim_privkey_wif, preimage_hex, swap = client.create_reverse_swap(50000)

  pay_task = asyncio.create_task(pay_invoice(swap.invoice))

  new_address = create_onchain_address()
  task = asyncio.create_task(client.claim_reverse_swap(
      boltz_id=swap.id,
      receive_address=new_address,
      lockup_address=swap.lockupAddress,
      redeem_script_hex=swap.redeemScript,
      blinding_key=swap.blindingKey,
      privkey_wif=claim_privkey_wif,
      preimage_hex=preimage_hex,
      zeroconf=True,
  ))
  txid = await task
  await pay_task
  ```





  ```console
  poetry install
  ```


  ```console
  poetry run boltz
  ```


  ```console
  cd docker
  chmod +x regtest
  ./regtest
  ```


  ```console
  poetry run pytest
  ```


pkgId: d10cf3cf1e1419895f1ff19941f1b5c55f8f872913a5f4b4640a84345ed03f68
name: python-bomail
arch: src
version: 0.9.4.1
epoch: 0
release: 1
summary: A homemade, hobbyist, hacky system for organizing and interacting with email.
url: https://bitbucket.org/bowaggonerpublic/bomail
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bomail-0.9.4.1-1.src.rpm
checksum_type: sha256
description:
  bomail is an experimental system for organizing and interacting with email.
  It can be installed with pip3 (the python package manager) via
      pip3 install bomail.
  This software is free.


  Homepage and information:
      https://www.bowaggoner.com/bomail/

  Source:
      https://www.bitbucket.org/bowaggonerpublic/bomail

  Version:
      0.9.4.1


  TODOs:
   - Tree view for threads (see reply structure rather than list by date)
   - Digital signatures and encryption

  Completed:
   - (0.9.3.0) Use XDG spec for where to put data and config
   - (0.9.2.0) Respect the reply-to header on emails


pkgId: 69aa87bd389395855af9c1f4c34594070ddaf33b4eb58417902ee58015b4b331
name: python-boman-cli
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: CLI tool of boman.ai
url: https://boman.ai
rpm_license: BSD 2-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boman-cli-2.3.0-1.src.rpm
checksum_type: sha256
description:
  Boman CLI is a Orchestration script written in python to run security scans on the customer's local or CI/CD environment and upload the results to Boman.ai SaaS server.




  ` pip install boman-cli`





  ` boman-cli -h`



  ` boman-cli -a test-saas`




  ` boman-cli -a test-yaml`



  ` boman-cli -a run`



  ` boman-cli -a run -u {URL}`




  `boman-cli -a run -fb {severity}`

  Severity can be high, medium or low.

  Example: boman-cli -a run -fb high




  `boman-cli -a run -config <custom_boman_yaml_file_name_here>`

  Example: boman-cli -a run -config ./customboman.yaml




  `boman-cli -a run -zap_session_script <custom_session_script_file_name_here>`

  Example: boman-cli -a run -zap_session_script ./session.js






  0  : Successfull scan
  1  : Server/SaaS error
  2  : Auth error
  3  : Docker/System error
  4  : Misconfig error







  - **New:** The pipeline configuration has been relocated from `boman.yaml` to the SaaS platform. Navigate to **Apps -> App menu -> Configure pipeline** to set it up. The current `boman.yaml` configuration will remain functional until it is officially deprecated.



      - New scan added: IaC.


      - Ignore files or directory for SAST and SCA


      - New scan added: SBOM.



      - New scan added: Container scan.
      - New Tool added for SCA scan type.




      - [Bug fix] Updated the Upload Logs success message

  Released on: 21 June 2024






      - Adapted to our new Boman SaaS platform

  Released on: 20 June 2024






      - Fixed docker-request libraries issue
      - Zap Authenticated scan
      - Fetch Git details
      - custom boman.yaml and zap session script load option

  Released on: 21 May 2024


pkgId: 2e334a9ae5f660832b3c18716f32e99f5c4f68f8cee86f903641e95011fab628
name: python-boman-cli
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: CLI tool of boman.ai
url: https://boman.ai
rpm_license: BSD 2-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boman-cli-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Boman CLI is a Orchestration script written in python to run security scans on the local or CI/CD environment and upload the results to Boman.ai SaaS server.




  ` pip install boman-cli`





  ` boman-cli -h`



  `boman-cli -a run -at <project token> -ct <customer token>`

  To obtain `project token` and `customer token`. Go to SaaS platform. Click on Apps -> app menu of the particular app -> Get Scan Token




  ` boman-cli -a test-saas`




  ` boman-cli -a test-yaml`



  ` boman-cli -a run`



  ` boman-cli -a run -u {URL}`




  `boman-cli -a run -fb {severity}`

  Severity can be high, medium or low.

  Example: boman-cli -a run -fb high




  `boman-cli -a run -config <custom_boman_yaml_file_name_here>`

  Example: boman-cli -a run -config ./customboman.yaml




  `boman-cli -a run -zap_session_script <custom_session_script_file_name_here>`

  Example: boman-cli -a run -zap_session_script ./session.js




  0  : Successfull scan
  1  : Server/SaaS error
  2  : Auth error
  3  : Docker/System error
  4  : Misconfig error







  - **New:** The pipeline configuration has been relocated from `boman.yaml` to the SaaS platform. Navigate to **Apps -> App menu -> Configure pipeline** to set it up. The current `boman.yaml` configuration will remain functional until it is officially deprecated.



      - New scan added: IaC.


      - Ignore files or directory for SAST and SCA


      - New scan added: SBOM.



      - New scan added: Container scan.
      - New Tool added for SCA scan type.




      - [Bug fix] Updated the Upload Logs success message

  Released on: 21 June 2024






      - Adapted to our new Boman SaaS platform

  Released on: 20 June 2024






      - Fixed docker-request libraries issue
      - Zap Authenticated scan
      - Fetch Git details
      - custom boman.yaml and zap session script load option

  Released on: 21 May 2024


pkgId: 3ae4a22105f9ef4da8e4a053627f9ac8aae967dbc9f8d033210cca75fedebd5e
name: python-bombcell
arch: src
version: 0.31
epoch: 0
release: 1
url: https://github.com/BombCell/bombcell
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bombcell-0.31-1.src.rpm
checksum_type: sha256
summary:
  Python port of BombCell. Automated quality control, curation and neuron classification of spike-sorted electrophysiology data.

description:
  Current WIP python version of BombCell.

  To install run `pip install bombcell`, there is a demo notebook available in demos/BC_demo.ipynb on the bombcell github


pkgId: 47489f68145a3f3717593ec94d36ab9c4d5d11d4ad7dbb86bd31d4d95a602982
name: python-bomf
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: BO4E Migration Framework
url: https://github.com/Hochfrequenz/bo4e_migration_framework
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bomf-0.11.3-1.src.rpm
checksum_type: sha256
description:
  BOMF is the BO4E Migration Framework.
  This repository contains the code of the Python package [bomf](https://pypi.org/project/bomf).

  ![Unittests status badge](https://github.com/Hochfrequenz/bo4e_migration_framework/workflows/Unittests/badge.svg)
  ![Coverage status badge](https://github.com/Hochfrequenz/bo4e_migration_framework/workflows/Coverage/badge.svg)
  ![Linting status badge](https://github.com/Hochfrequenz/bo4e_migration_framework/workflows/Linting/badge.svg)
  ![Black status badge](https://github.com/Hochfrequenz/bo4e_migration_framework/workflows/Black/badge.svg)
  ![PyPi Status Badge](https://img.shields.io/pypi/v/bomf)


  bomf is a framework, that allows its users to migrate data
  - from source systems (starting with the raw data extracts)
  - into an intermediate, common BO4E based data layer.
  - From there map data to individual target system data models
  - and finally create records in target systems (aka "loading").

  The framework
  - encourages user to program consistent data processing pipelines from any source to any target system
  - enforces users to adapt to structured and consistent patterns
  - and by doing so will lead to higher chances for maintainable and reusable code.


  The overall setup for a migration from 1-n source systems (A, B, C...) to 1-m target systems (1,2, 3...) might look like this:

  ```mermaid
  graph TD
      A[Source System A] -->|System A DB Dump| A2[Source A Data Model: A JSON Extract]
      B[Source System B] -->|System B CSV Export| B2[Source B Data Model: B CSV Files]
      A2 -->|SourceAToBo4eDataSetMapper| C{Intermediate BO4E Layer aka DataSets}
      B2 -->|SourceBToBo4eDataSetMapper| C
      C -->|validations| C
      C -->|Bo4eDataSetToTarget1Mapper| D1[Target 1 Data Model]
      C -->|Bo4eDataSetToTarget2Mapper| D2[Target 2 Data Model]
      C -->|Bo4eDataSetToTarget3Mapper| D3[Target 3 Data Model]
      D1 -->L1[Target 1 Loader]
      D2 -->L2[Target 2 Loader]
      D3 -->L3[Target 3 Loader]
      L1 -->M1[Target System 1]
      L2 -->M2[Target System 2]
      L3 -->M3[Target System 3]
  ```
  The Intermediate BO4E Layer (that consists of different so called DataSets) is kind of a contract between the code that maps *from the source data model* and the code that maps *to the target data model*.


  The migration of specific data from source to target is always the same:
  ```mermaid
  graph TD
      A1{Source Data 1} -->|Export| B1(All source data 1 extracts)
      B1 -->C1[Filter on source data 1 model aka Pre-Select 1]
      A2{Source Data 2} -->|Export| B2(All source data 2 extracts)
      B2 -->C2[Filter on source data 2 model aka Pre-Select 2]
      C1 -->|do not match filter predicate| Z{discarded data}
      C1 -->|match filter criteria| M(Custom Logic: SourceDataSetToBo4EDataSetMapper)
      C2 -->|do not match filter predicate| Z
      C2 -->|match filter criteria| M
      M -->|mapping| E(BO4E Data Sets)
      E -->F[Validation]
      F -->|obeys a validation rule|E
      F -->|violate any validation rule|Z
      F -->|passes all validations| G[BO4E to Target Mapper]
      G -->|mapping| H(target data model)
      H -->I[Target Loader]
      I -->|load target model|L1[Loader: 1. load to target]
      L1 -->|first: load to|T{Target System}
      L1 -->|then|L2[Loader: 2 optionally poll until target has processed data]
      L2 -->|second: poll until|T
      L2 -->|then|L3[Loader: 3 optionally verify the data have been processed correctly]
      L3 -->|finally: verify|T
      L3 -->|verification failed|Z
      L1 -->|loading failed|Z
      L3 -->|verification successful|Y[The End.]
      Z-->Z1[Monitoring and Logging]
      Z1-->Z2[Human Analyst]
      Z2 -.->|manually checks| T
      Z2 -.->|feedback: heuristically define new rules for|F
      Z2 -.->|feedback: heurisically define new filters for|C
  ```




  Please follow the [instructions in our Python Template Repository](https://github.com/Hochfrequenz/python_template_repository).
  tl;dr: `tox`.



  You are very welcome to contribute to this template repository by opening a pull request against the main branch.


pkgId: 155f999848c61a0ac4cbfb84d7aaabbbae9385ac113ef40cae430fb26a4f02ff
name: python-bomradarloop
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Create animated GIFs from BOM radar imagery
url: https://github.com/maddenp/bomradarloop
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bomradarloop-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This package provides animated GIF images of weather-radar imagery derived the Australian Bureau of Meteorology (http://www.bom.gov.au/australia/radar/).


pkgId: 073ded68cb9c9baf0358f2982b866a02fbeb3d0d19134e9227427afba4d644b5
name: python-bonbast
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Get currencies exchange rates for IRR from Bonbast.com
url: https://pypi.org/project/bonbast/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonbast-1.0.2-1.src.rpm
checksum_type: sha256
description:
  I tried my best to display the price data in a variety of ways that would be useful in a variety of circumstances.


  This will be the default mode if you run the program without any arguments. It will show the current prices for gold,
  coins, and the IRR exchange rate in separate tables.
  ![bonbast](https://user-images.githubusercontent.com/24422125/194708514-e7b76a69-0671-4a6c-a025-51f29558f087.png)

  In live mode, the program tries to update the prices in a specified interval. This is useful if you want to keep an eye
  on the prices.
  The website updates the prices every 30 seconds and the default value is 30 seconds as well. You can change this value
  by using the `-i` or `--interval` argument.

  In this mode, the program will show the prices as text in the terminal.
  ```shell
  $ bonbast live simple --show-only usd,eur,gbp,cad -i 300

  $ python -m bonbast live simple --show-only usd,eur,gbp,cad -i 300
  ```
  ![bonbast_live_simple](https://user-images.githubusercontent.com/24422125/194708537-09f98a47-a6b2-4489-a106-9bf22db6d527.png)

  In this mode, the program will show the prices in a table. It can only show one currency at a time.
  ```shell
  $ bonbast live currency --show-only usd,eur,gbp,cad -i 300

  $ python -m bonbast live currency --show-only usd,eur,gbp,cad -i 300
  ```
  ![bonbast_live_currency](https://user-images.githubusercontent.com/24422125/194708542-241d2e11-35ec-4868-91ec-30ff7ca5e6e0.png)

  This is useful if you want to see the prices for a specific date. You can use the `-d` or `--date` argument to specify
  the date. The date must be in the format `YYYY-MM-DD` or `YYYY/MM/DD`. Also, the date needs to be Gregorian.
  The date is valid from 2012-10-09 to one day before the current date.
  ```shell
  $ bonbast history --date 2020/10/10

  $ python -m bonbast history --date 2020/10/10
  ```
  ![bonbast_history](https://user-images.githubusercontent.com/24422125/194708555-fb5ada09-8e74-497d-8b61-74f27dea9220.png)

  This is useful if you want to see the price of a currency in a specific date range. You can use the `--start-date`
  argument to specify the start date and `--end-date` for the end date. The date must be in the format `YYYY-MM-DD`
  or `YYYY/MM/DD`. Also, the date needs to be Gregorian.
  If start or end date is not specified, the end date will default to today and the start date will be set to 30 days prior
  to the end date.
  The date is valid from 2012-10-09 to one day before the current date.
  ```shell
  $ bonbast graph eur
  $ bonbast graph eur --start-date 2023-01-02
  $ bonbast graph eur --start-date 2023-02-12 --end-date 2023-05-09

  $ python -m bonbast graph eur
  ```
  ![bonbast_graph](https://github.com/SamadiPour/bonbast/assets/24422125/eced2062-ed93-4004-a274-cec11708463b)

  This is useful if you want to convert a value from one currency to Rial or from Rial to another currency.
  If you want to convert from a currency to Rial, you need to use `-s` or `--source` argument to specify the currency you
  want to convert from.
  ```shell
  $ bonbast convert -s EUR 12.5

  $ python -m bonbast convert -s EUR 12.5
  ```
  If you want to convert from Rial to another currency, you need to use the `-d` or `--destination` argument to specify
  the currency you want to convert to.
  ```shell
  $ bonbast convert -d USD 1837850

  $ python -m bonbast convert -d USD 1837850
  ```
  You can also use `--only-buy` or `--only-sell` to specify which price you want to use.
  ```shell
  $ bonbast convert -d USD 1837850 --only-buy
  $ bonbast convert -d USD 1837850 --only-sell

  $ python -m bonbast convert -d USD 1837850 --only-buy
  $ python -m bonbast convert -d USD 1837850 --only-sell
  ```
  ![bonbast_convert](https://user-images.githubusercontent.com/24422125/194708562-38f9f08c-9bc7-41d0-9889-04f38007b7f3.png)

  It can be useful if you want to use the result of the program in another program. You can also pipe the output in
  terminal to another program like `JQ`.
  ```shell
  $ bonbast export

  $ python -m bonbast export
  ```
  ![bonbast_export](https://user-images.githubusercontent.com/24422125/194708575-58fc19a5-9aa9-4e6d-b020-a40835d9d55d.png)

  There is also a way to pretty print the json output. You can use the `--pretty` argument to do that. It helps to see the
  output in a more readable way.
  ```shell
  $ bonbast export --pretty

  $ python -m bonbast export --pretty
  ```
  ![bonbast_export_pretty](https://user-images.githubusercontent.com/24422125/194708592-471a189b-e3f4-4a29-b36c-ad536d93822e.png)

  | Flag | Currency          | Code |
  |:----:|-------------------|:----:|
  | 🇺🇸 | US Dollar         | USD  |
  | 🇪🇺 | Euro              | EUR  |
  | 🇬🇧 | British Pound     | GBP  |
  | 🇨🇭 | Swiss Franc       | CHF  |
  | 🇨🇦 | Canadian Dollar   | CAD  |
  | 🇦🇺 | Australian Dollar | AUD  |
  | 🇸🇪 | Swedish Krona     | SEK  |
  | 🇳🇴 | Norwegian Krone   | NOK  |
  | 🇷🇺 | Russian Ruble     | RUB  |
  | 🇹🇭 | Thai Baht         | THB  |
  | 🇸🇬 | Singapore Dollar  | SGD  |
  | 🇭🇰 | Hong Kong Dollar  | HKD  |
  | 🇦🇿 | Azerbaijani Manat | AZN  |
  | 🇦🇲 | 10 Armenian Dram  | AMD  |
  | 🇩🇰 | Danish Krone      | DKK  |
  | 🇦🇪 | UAE Dirham        | AED  |
  | 🇯🇵 | 10 Japanese Yen   | JPY  |
  | 🇹🇷 | Turkish Lira      | TRY  |
  | 🇨🇳 | Chinese Yuan      | CNY  |
  | 🇸🇦 | Saudi Riyal       | SAR  |
  | 🇮🇳 | Indian Rupee      | INR  |
  | 🇲🇾 | Malaysian Ringgit | MYR  |
  | 🇦🇫 | Afghan Afghani    | AFN  |
  | 🇰🇼 | Kuwaiti Dinar     | KWD  |
  | 🇮🇶 | 100 Iraqi Dinar   | IQD  |
  | 🇧🇭 | Bahraini Dinar    | BHD  |
  | 🇴🇲 | Omani Rial        | OMR  |

rpm_license:
  MIT License  Copyright (c) 2022 Amir Hossein SamadiPour  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: f3f228f3a3abcdf74458fd82dc427792040c477bbf5a630166c5827869dbd321
name: python-bond-api
arch: src
version: 0.1.18
epoch: 0
release: 1
summary: Asynchronous Python wrapper library over Bond Local API
url: https://github.com/prystupa/bond-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bond-api-0.1.18-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python wrapper library over Bond Local API



  From PyPi:

  ```bash
  pip3 install bond-api
  ```


  ```python3
  import asyncio

  from aiohttp import ClientResponseError, ClientConnectorError

  from bond_api import Bond, Action


  async def main():
      """Example of library usage."""

      bond = Bond("[your ip or hostname here]", "[your bond API token here]")

      try:
          print("Version:")
          print(await bond.version())

          print("Device IDs:")
          device_ids = await bond.devices()
          print(device_ids)

          print("Devices:")
          devices = await asyncio.gather(*[bond.device(device_id) for device_id in device_ids])
          print(devices)

          print("Devices Properties:")
          properties = await asyncio.gather(*[bond.device_properties(device_id) for device_id in device_ids])
          print(properties)

          print("Devices State:")
          state = await asyncio.gather(*[bond.device_state(device_id) for device_id in device_ids])
          print(state)

          print("Turn on fan!")
          await bond.action("[your fan device ID here]", Action.turn_on())

          print("Change fan speed!")
          await bond.action("[your fan device ID here]", Action.set_speed(2))

          print("Turn off fan!")
          await bond.action("[your fan device ID here]", Action.turn_off())

      except ClientResponseError as x:
          print("Client response error: ", x)
      except ClientConnectorError as x:
          print("Client connector error: ", x)


  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main())
  ```


pkgId: 4c4ebe64caba6493e2cfb387a9ff0c6a876f0e75994aa5a710ce40bf7a8a1df8
name: python-bond-async
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Asynchronous Python wrapper library over Bond Local API
url: https://github.com/bondhome/bond-async
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bond-async-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python wrapper library over Bond Local API

  Forked from https://github.com/prystupa/bond-api
  Thanks @prystupa for the great work!



  From PyPi:

  ```bash
  pip3 install bond-async
  ```


  ```python3
  import asyncio

  from aiohttp import ClientResponseError, ClientConnectorError

  from bond_async import Bond, Action


  async def main():
      """Example of library usage."""

      bond = Bond("[your ip or hostname here]", "[your bond API token here]")

      try:
          print("Version:")
          print(await bond.version())

          print("Device IDs:")
          device_ids = await bond.devices()
          print(device_ids)

          print("Devices:")
          devices = await asyncio.gather(*[bond.device(device_id) for device_id in device_ids])
          print(devices)

          print("Devices Properties:")
          properties = await asyncio.gather(*[bond.device_properties(device_id) for device_id in device_ids])
          print(properties)

          print("Devices State:")
          state = await asyncio.gather(*[bond.device_state(device_id) for device_id in device_ids])
          print(state)

          print("Turn on fan!")
          await bond.action("[your fan device ID here]", Action.turn_on())

          print("Change fan speed!")
          await bond.action("[your fan device ID here]", Action.set_speed(2))

          print("Turn off fan!")
          await bond.action("[your fan device ID here]", Action.turn_off())

      except ClientResponseError as x:
          print("Client response error: ", x)
      except ClientConnectorError as x:
          print("Client connector error: ", x)


  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      loop.run_until_complete(main())
  ```


pkgId: 71e229997e191d3dcb4bed766a19a392ee8d60454a3d27626e10bd82d0b2485b
name: python-bond-pricing
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: Bond Price with YTM/zero-curve & NPV, IRR, annuities
url: https://github.com/jrvarma/bond_pricing
rpm_license: OSI Approved :: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bond-pricing-0.7.3-1.src.rpm
checksum_type: sha256
description:
  `pip install bond_pricing`

  For installation without pulling in `scipy` as a dependency, see [below](#reducing-dependencies)

  The source code is at <https://github.com/jrvarma/bond_pricing> if you want to go that route.



  This package provides bond pricing functions as well as basic NPV/IRR functions. Bond valuation can be done using an yield to maturity or using a zero yield curve. There is a convenience function to construct a zero yield curve from a few points on the par bond or zero yield curve or from Nelson Siegel parameters.

  The documentation is available at <https://bond-pricing.readthedocs.io/>

  The bond valuation functions can be used in two modes:

  * The first mode is similar to spreadsheet bond pricing functions. The settlement date and maturity date are given as dates and the software calculates the time to maturity and to each coupon payment date from these dates. For any `daycount` other than simple counting of days (ACT/365 in ISDA terminology), this packages relies on the `isda_daycounters` module that can be downloaded from <https://github.com/miradulo/isda_daycounters>

  * Maturity can be given in years (the `settle` parameter is set to `None` and is assumed to be time 0) and there are no dates at all. This mode is particularly convenient to price par bonds or price other bonds on issue date or coupon dates. For example, finding the price of a 7 year 3.5% coupon bond if the prevailing yield is 3.65% is easier in this mode as the maturity is simply given as 7.0 instead of providing a maturity date and specifying today's date. Using this mode between coupon dates is not so easy as the user has to basically compute the day count and year fraction and provide the maturity as say 6.7 years.

  * Bond Valuation
      - Bond price using YTM (`bond_price`) or using zero yield curve (`zero_curve_bond_price`)
      - Accrued interest and dirty bond prices using YTM (`bond_price_breakup`)  or using zero yield curve (`zero_curve_bond_price_breakup`)
      - Duration using YTM (`bond_duration`)
      - Yield to maturity (`bond_yield`).

  * Zero curve construction
      - bootstrap zero yields from par yields (`par_yld_to_zero`) or vice versa (`zero_to_par`)
      - compute zero rates from Nelson Siegel parameters (`nelson_siegel_zero_rate`)
      - construct zero prices from par or zero yields at selected knot points using a cubic spline or assuming a flat yield curve (`make_zero_price_fun`)

  * Present Value functions
      - Net Present Value (`npv`)
      - Internal Rate of Return (`irr`)
      - Duration (`duration`).
    These functions allow different compounding frequencies: for example, the cash flows may be monthly while the interest rate is semi-annually compounded. The function `equiv_rate` converts between different compounding frequencies.

  * Annuity functions
      - Annuity present value (`annuity_pv`)
      - Future value (`annuity_fv`)
      - Implied interest rate (`annuity_rate`)
      - Number of periods to achieve given present value or terminal value (`annuity_periods`).
      - Periodic instalment to achieve given present value or terminal value (`annuity_instalment`).
      - Breakup of instalment into principal and interest (`annuity_instalment_breakup`)

    In these functions also, the cash flow frequency may be different from the compounding frequency.



  This module requires `numpy`, `pandas` and `scipy`. In some environments, installing `scipy` may be difficult, and only a couple of functions (the `newton` root finder and `CubicSpline` interpolation) are actually needed from the huge `scipy` package. So a provision has been made to avoid `scipy` with some loss of functionality (the `newton` root finder is replaced by a less sophisticated root bracketing and bisection algorithm and `CubicSpline` interpolation is replaced by the much cruder linear interpolation). At run time, the module checks for the availability of `scipy` and uses the cruder methods (with a suitable warning) if `scipy` is not available.

  To install this package without pulling in `scipy` as a dependency, do the following:

  ```
  git clone https://github.com/jrvarma/bond_pricing.git
  export no_scipy=1
  pip install bond_pricing
  ```


pkgId: d6bc21010f946e3a74344a6df9e9ef0cbf5a9fca834c41866fc90f453bfc4799
name: python-bondai
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: An AI-powered console assistant with a versatile API for seamless integration into applications.
url: https://bondai.dev
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bondai-0.3.1-1.src.rpm
checksum_type: sha256
description:
  <a href="https://bondai.dev">
  <p align="center">
  <img src="assets/bondai-logo.png" alt="Description or Alt text" style="border-radius: 10px; width: 50%;"  alt="logo">
  </p>
  </a>

  <p align="center">
      <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
      <a href="https://pypi.org/project/bondai/"><img src="https://img.shields.io/pypi/v/bondai" alt="PyPI"></a>
      <a href="https://hub.docker.com/r/krohling/bondai"><img src="https://img.shields.io/docker/v/krohling/bondai?logo=docker" alt="Docker"></a>
      <a href="https://colab.research.google.com/drive/1Rmzosq6LD_ZR3MkqQO1M1Af27VAaYNRE?usp=sharing" style={{marginLeft: '10px'}}>
          <img src="https://colab.research.google.com/assets/colab-badge.svg" style={{marginLeft: '10px'}} alt="PyPI"/>
      </a>
  </p>
  <p align="center"><em>Build highly capable Single and Multi-Agent Systems.</em></p>



  Checkout the BondAI Homepage ([https://bondai.dev](https://bondai.dev)) for in depth documentation, examples and API specification.



  There are 3 ways to use BondAI:

  1) 🛠️ **Command Line Interface (CLI)** - This is the easiest way to get up and running fast. Run BondAI on your command line with a pre-configured set of tools.

  2) 🐋 **Docker** - Running BondAI in a Docker container is recommended if you plan on using tools that run code or directly access your shell.

  3) 🏗️ **Start Coding with BondAI** - Integrate BondAI into your own codebase and start building your own agents.



  Installing BondAI is easy:

  ```bash
  pip install bondai
  ```



  Once you've installed BondAI using `pip install bondai` the CLI will be available as an executable accessible simply by running `bondai` in your shell. [Learn more about all of the tools and options available through the CLI](https://bondai.dev/docs/cli).

  Before running `bondai` you will need to set the OPENAI_API_KEY environment variable.
  ```bash
  export OPENAI_API_KEY=sk-XXXXXXXXXX
  ```

  Once the environment variable has been set you can run `bondai` to start the CLI.

  ```bash
  Loading BondAI...
  ******************ENTERING CHAT******************
  You are entering a chat with BondAI...
  You can exit any time by typing 'exit'.

  Hello! I'm BondAI, your friendly and helpful assistant. I'm here to assist you with any tasks or questions you might have. How can I assist you today?

  I want you to write a story about unicorns and save it to a file named unicorns.md.
  Using tool file_write: Writing a story about unicorns and saving it to a file named unicorns.md
  Using tool final_answer...

  A story about unicorns has been successfully written and saved to a file named unicorns.md. The story is set in an enchanted forest and describes the magical and majestic nature of unicorns, their daily routines, and their harmonious relationship with other creatures in the forest.
  ```




  BondAI Docker images are available on [DockerHub here](https://hub.docker.com/r/krohling/bondai). If you intend to use tools that run arbitrary code (*PythonREPLTool*) or access your shell (*ShellTool*) it is highly recommended that you run BondAI in a Docker container as these tools can damage your machine.

  Before running the BondAI Docker container it is recommended that you create a directory named 'agent-volume' and mount it as a volume on the container. This will be used as the Agent's working directory and allows you to easily share files with the Agent.

  ```bash
  mkdir agent-volume
  docker pull krohling/bondai:latest
  docker run -it --rm \
             -v ./agent-volume:/agent-volume \
             -w /agent-volume \
             OPENAI_API_KEY=sk-XXXXXXXXXX \
             bondai:latest bondai
  ```



  BondAI has a straightforward API for creating powerful AI Agents. Check out our [examples](https://bondai.dev/docs/category/examples) for ideas on how to get started.  Remember to set your *OPENAI_API_KEY* environment variable before running your BondAI Agent.

  ```python
  from bondai.agents import Agent
  from bondai.tools.search import DuckDuckGoSearchTool
  from bondai.tools.website import WebsiteQueryTool
  from bondai.tools.file import FileWriteTool

  task = """I want you to research the usage of Metformin as a drug to treat aging and aging related illness.
  You should only use reputable information sources, ideally peer reviewed scientific studies.
  I want you to summarize your findings in a document named metformin.md and includes links to reference and resources you used to find the information.
  Additionally, the last section of your document you should provide a recommendation for a 43 year old male, in good health and who regularly exercises as to whether he would benefit from taking Metformin.
  You should explain your recommendation and justify it with sources.
  Finally, you should highlight potential risks and tradeoffs from taking the medication."""

  Agent(tools=[
    DuckDuckGoSearchTool(),
    WebsiteQueryTool(),
    FileWriteTool()
  ]).run(task)
  ```



  BondAI comes out of the box with a powerful set of integrations.

  |     |  |  |
  | -------- | ------- |------- |
  | <img src="assets/logos/openai-logo.png" alt="openai logo" width="50"/> | **OpenAI**     | BondAI supports any combination of OpenAI models and services including GPT-4, GPT-3.5, Dalle-E 3, and Embeddings.  |
  | <img src="assets/logos/azure-logo.png" alt="azure logo" width="50"/> | **Microsoft Azure**     | BondAI fully supports connectivity to GPT-N, Dalle-E and Embedding APIs through [Microsoft's Azure OpenAI services](https://azure.microsoft.com/en-us/products/ai-services/openai-service).  |
  | <img src="assets/logos/google-logo.png" alt="google logo" width="50"/>  | **Google Search**    | Allows BondAI to search the internet. [Requires a Google Search API Key and CSE ID](https://developers.google.com/custom-search/v1/introduction) |
  | <img src="assets/logos/duckduckgo-logo.png" alt="duckduckgo logo" width="50"/> | **DuckDuckGo**     | Allows BondAI to search the internet. No API keys required. |
  | <img src="assets/logos/alpaca-markets-logo.jpeg" alt="alpaca markets logo" width="50"/> | **Alpaca Markets**     | Allows BondAI to buy and sell stocks and crypto. [Requires an Alpaca Markets account.](https://alpaca.markets/)  |
  | <img src="assets/logos/postgres-logo.jpeg" alt="postgres logo" width="75"/>    | **PostgreSQL**    | BondAI can automatically extract the schema from a Postgres DB and process natural language queries. |
  | <img src="assets/logos/blandai-logo.jpeg" alt="bland.ai logo" width="50"/> | **Bland AI**     | Allows BondAI to make phone calls and process/retrieve call transcripts. [Requires a Bland.ai account.](https://www.bland.ai/)  |
  | <img src="assets/logos/gmail-logo.png" alt="gmail logo" width="50"/> | **Gmail**     | Allows BondAI to search and read emails.  |


pkgId: efc54fd2a79bc01ea1ade7ced00bf4f46bc86a072e0c7deebec01155048f8bd7
name: python-bondzai.idetect40-interface
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Bondzai iDetect 4.0 interface
url: https://pypi.org/project/bondzai.idetect40-interface/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bondzai.idetect40-interface-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Description
  ~~~~~~~~~~~
  Bondzai iDetect 4.0 interface provides python library to communicate with one product instance via socket
  Installation
  ~~~~~~~~~~~~
     pip install bondzai.idetect40-interface
  Usage
  ~~~~~
     from bondzai.idetect40_interface import socket


pkgId: bf469fdc7a1f18ac801caab472c70d81f4e78d4205922d2239a2d2fb7729ccd0
name: python-bonobo-sqlalchemy
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Bonobo SQLAlchemy Extension
url: https://www.bonobo-project.org/with/sqlalchemy
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonobo-sqlalchemy-0.6.1-1.src.rpm
checksum_type: sha256
description:
  SQLAlchemy extension for Bonobo, bringing SQL databases to the Extract-Tranform-Load framework.
  /!\ CURRENTLY REWRITING THE CODE FROM RDC.ETL, DON'T USE BEFORE AT LEAST ALPHA STATUS /!\
  If you want to use SQLAlchemy with bonobo, this is the way to go. Note that it's not required to connect to databases,
  you can also use raw database connections (psycopg2, etc.), but it's probably easier to use an established DBAL.
  * Documentation: http://docs.bonobo-project.org/


pkgId: 1df9a75fcbe6183fee3954e4db09ff02b4a2f1a3f89e3467c813db75d06151ad
name: python-bonsai-classifications
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: "Python package classifications of the util workflow stage of the BONSAI database"
url: https://gitlab.com/bonsamurais/bonsai/util/classifications
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonsai-classifications-0.3.7-1.src.rpm
checksum_type: sha256
description:
  The BONSAI classifications Python package is a part of the [Getting The Data Right](https://bonsamurais.gitlab.io/bonsai/documentation) project.

  Here, all the classifications, which are used in the Bonsai database, are created and stored as csv files.
  The csv files can be found under [/src/classifications/data](https://gitlab.com/bonsamurais/bonsai/clean/classifications/-/tree/main/src/classifications?ref_type=heads). The structure of organising these files follows the [Bonsai ontology](https://github.com/BONSAMURAIS/ontology) and thus has the following folders:
  - activitytype (includes: `industry_activity`, `government_activity`, `treatment_activity`, `non_profit_institution_serving_household`, `household_production`, `household_consumption`, `market_activity`, `natural_activity`, `auxiliary_production_activity`, `change_in_stock_activity`, `other_activity`)
  - flowobject (includes `industry_product`, `material_for_treatment`, `market_product`, `government_product`, `household_product`, `needs_satisfaction`, `emission`, `direct_physical_change`, `natural_resource`, `economic_flow`, `social_flow`)
  - location
  - unit
  - time

  Since the Bonsai ontology does not cover all required topics, additional folders are added:
  - dataquality
  - uncertainty

  A comprehensive documentation of the classification package is availbale [here](https://bonsamurais.gitlab.io/bonsai/util/classifications/index.html)


  The csv files (tables) of each folder (datapackage) are organised in tabular format. Each of the mentioned folders represents a valid dataio.datapackage created with the Python package [dataio](https://bonsamurais.gitlab.io/bonsai/util/dataio/index.html). The following types of tables with its prefixes are used:
  - tree table `tree_`
  - concordance table `conc_`
  - dimension table `dim_`
  - pairwise cocncordance table `concpair_`


  Tree tables are used for classifications which have a tree structure, meaning that the classification is structured hierarchically with multiple levels. The classification starts with broad categories at the top level and then branches out into more specific subcategories as you move down the hierarchy.

  The following column names are used:
  - `code`: code of the item
  - `parent_code`: code of the items parent
  - `name`: name of the item
  - `level`: the items level in the tree structure (from 0 to n)
  - `prefixed_id`: unique id (uuid4)


  A concordance table is used to establish equivalences or relationships between different classification systems. It provides mappings between codes of a classification system and codes from another classification system. A relationship between codes can have four different types:

  - **One-to-One (1:1) Concordance**: In a one-to-one concordance, each category or code in one classification system is mapped to exactly one category or code in another classification system, and vice versa. This type of mapping implies a direct and unambiguous correspondence between the two systems.

  - **One-to-Many (1:M) Concordance**: In a one-to-many concordance, each category or code in one classification system is mapped to multiple categories or codes in another classification system. However, each category or code in the second system is only mapped to one category or code in the first system. This type of mapping implies that one category or code in the first system may encompass multiple categories or codes in the second system.

  - **Many-to-One (M:1) Concordance**: In a many-to-one concordance, multiple categories or codes in one classification system are mapped to a single category or code in another classification system. However, each category or code in the second system is only mapped to one category or code in the first system. This type of mapping implies that multiple categories or codes in the first system are aggregated or collapsed into a single category or code in the second system.

  - **Many-to-Many (M:M) Concordance**: In a many-to-many concordance, multiple categories or codes in one classification system are mapped to multiple categories or codes in another classification system. This type of mapping indicates complex relationships where there isn't a straightforward one-to-one correspondence between the categories or codes in the two systems.

  The following column names are used:
  - `<tree_classification_A>`: code of classification A
  - `<tree_classification_A>`: code of classification B which is mapped to the code of classification A
  - `comment`: comment on the type of concordance
  - `prefixed_id`: unique id (uuid4)

  The requirements for these table types are specified [here](https://dataio-bonsamurais-bonsai-util-a55d63cbbbcf635b952059f8b8a12a71.gitlab.io/syntax.html#field).


  A dimension table is used for classifications which do not have a tree structure.

  The following column names are used:
  - `code`: code of the item
  - `name`: name of the item
  - `description`: description of the item
  - `prefixed_id`: unique id (uuid4)



  This type of concordance table is used to map pairwise codes. For instance, some data providers such as `UNdata` and `IEA` are using combined codes for an activity (e.g. for "production of", "electricity production by") and `flowobject` (e.g. "coal") to express a `bonsai_activitytype` ("A_COAL", "A_PowC"). In some cases, when the `conc_` tables for  `activitytype` and `flowobject`, which map single relations, are not sufficient to create these pairwise concordances, it is reasonable to make it explicit. The mapping relationships between the pairwise codes can be the same as in the `conc_` tables.


  The following column names are used:
  - `tree_bonsai_activitytype`: code of the Bonsai activitytype
  - `tree_bonsai_flowobject`: code of the Bonsai flowobject
  - `tree_other_activitytype`: code of the other classification activitytype
  - `tree_other_flowobject`: code of the other classification flowobject
  - `other_classification`: name of the other classification schema
  - `comment`: comment on the type of concordance
  - `prefixed_id`: unique id (created by `uuid4`)


  To use the classification, you can install the package via pip. Replace `<version>` by a specific tag or branch name.

  ```
  pip install git+ssh://git@gitlab.com/bonsamurais/bonsai/util/classifications@<version>
  ```

  From pypi, do:
  ```
  pip install bonsai_classifications
  ```


  All classifications are provided as `dataio.datapackage` which include the tables as `pandas.DataFrame`. E.g., you can do the following get the classification `tree` for industry activities of Bonsai:
  ```python
  import classifications

  classifications.activitytype.datapackage.tree_bonsai
  ```
  :::{note} The datapackage object includes also the tables of other classifications.
  :::

  You can also get the concordance tables and external classifications in the similar way, using the `datapackage` object.

  The activities and flowobjects of Bonsai can be also used directly as objects. By doing the following, you would get the `name` of the `A_Chick` activity.
  ```python
  import classifications

  classifications.activitytype.bonsai.A_Chick.name
  ```


  - `lookup()` for searching strings in code names
  - `get_children()` to get all codes those have the same parent code
  - `create_conc()` to create a concordance table
  - `disaggregate_bonsai()` for adding new codes, which disaggregate an existing code

  To search for certain key words in a table, you can use the line of code below. This returns a pandas DataFrame with rows that have "coal" in the `name` column.
  ```python
  classifications.flowobject.datapackage.tree_bonsai.lookup("coal")
  ```

  To get all children of a certain code (here for treatment activities in Bonsai), you can do:
  ```python
  classifications.activitytype.datapackage.tree_bonsai.get_children(parent_code="at")
  ```

  The package also helps to create new concordance tables. When having two concordance tables, one for mapping codes of classification `a` to `b`, and the other for mapping `b` to `c`, you can use the following:

  df_1:
  | a | b |
  | - | - |
  | 01.01 | x |
  | ... | ... |

  df_2:
  | b | c |
  | - | - |
  | x | YXDA |
  | ... | ... |

  ```python
  df_3 = classifications.create_conc(df_1, df_2, source="a", target="c", intermediate="c")

  ```
  df_3:
  | a | c |
  | - | - |
  | 01.01 | YXDA |
  | ... | ... |

  To disaggregate existing codes of the Bonsai classification, you can use the `disaggregate_bonsai()` method. Depending on the category, e.g. `activitytype` or `flowobject`, you can call that method.
  To indicate the which code you want to disaggregate, you need to provide a dictionary, with the old code of Bonsai as keys. The value corresponding to that key is a list of tuples. Each tuple represents a new code. The first entry of that tuple is the code, the second entry is the name, and the third is a mapping dictionary. This mapping dictionary includes the name of another classification scheme (other than Bonsai) as key, and a list of strings, which are the codes of the other classification now represented by the new code.
  ```python
  codes = {"disaggregations":
            [
              {"old_code" : "A_Paper",
               "new_codes":
                 [
                  {"code": "New_Paper1",
                   "description": "new paper production 1",
                   "mappings": {"nace_rev2": ["10.02","01.13"]}
                  },
                  {"code": "New_Paper2",
                   "description": "new paper production 2",
                   "mappings": {}
                  }
                  ]
              }
            ]
  }

  d = classifications.activitytype.datapackage.disaggregate_bonsai(codes)
  ```

  Get the pandas DataFrames that are modified.
  ```python
  d["tree_bonsai"]
  d["conc_bonsai_nace_rev2"]
  ```

  To use that function via terminal, execute `python disaggregate_bonsai.py <bonsai_categorty> <path/to/disaggregaion.yaml> <directory/for/updated/files>`. `<bonsai_category>` can be for instance `activitytype` or `flowobject`.

  :::{note} To disaggregate an existing code, you need to provide at least 2 new codes. It is assumed that all entities covered by the new codes are equal to the entities of the existing code.


pkgId: 6536dd6c4a084c8a0dbd2ff0a04121dd304331928280e94b19d4e41337325588
name: python-bonsai-cli
arch: src
version: 1.0.19
epoch: 0
release: 1
summary: A python library for making API calls to the Bonsai Platform.
url: https://github.com/BonsaiAI/bonsai-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonsai-cli-1.0.19-1.src.rpm
checksum_type: sha256
description:
  A python library for making API calls to Bonsai BRAIN.
  Documentation for the Bonsai CLI can be found on the Bonsai Docs website.
  **Guide to CLI installation and usage:** https://docs.microsoft.com/en-us/bonsai/cli/#installation
  **Full CLI Reference Documentation:** https://docs.microsoft.com/en-us/bonsai/cli/


pkgId: 53889ce2a5aee966627987bff0302f9bc0917633118bcd2f375c44a308e99606
name: python-bonsai-code
arch: src
version: 0.6.8
epoch: 0
release: 1
summary: Static analysis library.
url: https://github.com/git-afsantos/bonsai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonsai-code-0.6.8-1.src.rpm
checksum_type: sha256
description:
  | Bonsai is an attempt to provide a miniature and refined representation
    for the
  | often cumbersome **syntax trees** and **program models**.
  | This idea, of providing a *smaller tree* that is more or less the same
    thing,
  | is where the name comes from.
  | This work started as part of an analysis tool that I am developing for
    my own
  | research. I am interested in analysing `ROS`_
  | robotics applications, which are often written in C++.
  | Since free C++ analysis tools are *rather scarce*, I tried
  | to come up with my own, using the Python bindings of the ``clang``
    compiler.
  | At the moment of this writing, I am aware that these bindings are
    incomplete
  | in terms of AST information they provide.
  | As this analysis tool developed, I realized that the C++ analysis
    features
  | are independent of ROS or any other framework, and that this kind of
    tool
  | might be useful for someone else, either as is, or as a starting point
    for
  | something else.


pkgId: c265a5be284f3085e5a5aa779d4876a2fe6ba326e13a2bff387be8202763be89
name: python-bonsai-dataio
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: "Python package dataio of the util workflow stage of the BONSAI database"
url: https://gitlab.com/bonsamurais/bonsai/util/dataio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonsai-dataio-4.3.0-1.src.rpm
checksum_type: sha256
description:
  The BONSAI dataio Python package is a part of the [Getting The Data Right](https://bonsamurais.gitlab.io/bonsai/documentation) project.


  The `dataio` package is designed to facilitate the management of data resources through easy-to-use APIs for reading, writing, and updating data in various formats, with a focus on maintaining comprehensive metadata about each data resource.

  Read the [BONSAI data architecture](https://bonsamurais.gitlab.io/bonsai/documentation/architecture/data) for background information on table types, foreign keys, and related concepts.



  To install the dataio package as a standalone package type in the command line:

  ```bash
  pip install git+ssh://git@gitlab.com/bonsamurais/bonsai/util/dataio@<version>
  ```

  dataio uses HDF5 stores for storing matrices. You possibly need to install HDF5 systemwide before you can install dataio. On Mac you can do this by using brew `brew install hdf5`.

  To install as dependency in a package add to the field `install_requires` in  `setup.cfg`:

  ```bash
  util_dataio @ git+ssh://git@gitlab.com/bonsamurais/bonsai/util/dataio@<version>
  ```

  You can find the list of versions [here](https://bonsamurais.gitlab.io/bonsai/util/dataio/changelog.html).



  - Resource Management: Manage your data resources with a structured CSV repository that supports adding, updating, and listing data resources.
  - Data Validation: Validate data against predefined schemas before it is saved to ensure integrity.
  - Data Retrieval and Storage: Easily retrieve and store dataframes directly from/to specific tasks and data resources.




  Before using the dataio package, set the BONSAI_HOME environment variable to point to your project's home directory where data resources will be managed:

  ```python
  import os
  from pathlib import Path

  os.environ["BONSAI_HOME"] = str(Path("path/to/your/data").absolute())
  ```

  If you don't want to set this variable, you need to provide an absolut path when setting up your resource file and then make sure that in that resource file all locations are also absolut.

  The execption to this is when you interact with the data through the online API, in this case you also don't need to set the env.

  NOTE THAT THIS IS NOT SUPPORTED YET.



  Instantiate a CSV resource repository to manage your data resources:

  ```python
  from dataio.resources import CSVResourceRepository

  repo = CSVResourceRepository(Path("path/to/your/data"))
  ```

  Currently we only support CSVResourceRespository. In the future you will also be able to use the APIResourceRepository class.



  Add new resources to the repository:

  ```python
  from dataio.schemas.bonsai_api import DataResource
  from datetime import date

  resource = DataResource(
      name="new_resource",
      schema_name="Schema",
      location="relative/or/absolut/path/to/the/resource.csv",
      task_name="task1",
      stage="collect",
      data_flow_direction="input",
      data_version="1.0.1",
      code_version="2.0.3",
      comment="Initial test comment",
      last_update=date.today(),
      created_by="Test Person",
      dag_run_id="12345",
  )

  repo.add_to_resource_list(resource)
  ```

  Not all fields need to be set. The schema name needs to correspond to one of the schema names defined in dataio.schemas

  For the CSVResourceRepository, the relative locations provided via the resources.csv file are relative to that resources.csv file!



  Update an existing resource in your repository:

  ```python
  resource.created_by = "New Name"
  repo.update_resource_list(resource)
  ```



  Retrieve specific resource information using filters:

  ```python
  result = repo.get_resource_info(name="new_resource")
  print(result)
  ```

  You can store and read data using different file formats. The way data is stored depends on the file extension used in the `location` field. The `location` field also is always relative to the resources.csv file. Please don't put absolute paths there.

  The `last_update` field is set automatically by dataio. Please don't overwrite this field.

  Currently the following data formats are supported:

  [".json", ".yaml"]


  [".parquet", ".xlsx", ".xls", ".csv", ".pkl"]


  [".hdf5", ".h5"]
  Note matrices need to use a `MatrixModel` schema.



  Write data to a resource and then read it back to verify:

  ```python
  import pandas as pd

  data_to_add = pd.DataFrame({
      "flow_code": ["FC100"],
      "description": ["Emission from transportation"],
      "unit_reference": ["unit"],
      "region_code": ["US"],
      "value": [123.45],
      "unit_emission": ["tonnes CO2eq"],
  })

  repo.write_dataframe_for_task(
      resource_name="new_resource",
      data=data_to_add,
      task_name="footprint_calculation",
      stage="calculation",
      location="calculation/footprints/{version}/footprints.csv",
      schema_name="Footprint",
      data_flow_direction="output",
      data_version="1.0",
      code_version="1.1",
      comment="Newly added data for emissions",
      created_by="Test Person",
      dag_run_id="run200",
  )

  retrieved_data = repo.get_dataframe_for_task("new_resource")
  print(retrieved_data)

  ```



  To ensure everything is working as expected, run the provided test suite:

  ```bash
  pytest tests -vv
  ```
  or

  ```bash
  tox
  ```
  This will run through a series of automated tests, verifying the functionality of adding, updating, and retrieving data resources, as well as reading and writing data based on resource descriptions.



  Contributions to the dataio package are welcome. Please ensure to follow the coding standards and write tests for new features. Submit pull requests to our repository for review.


pkgId: 0e122913c1bc9929ad8826858db76ba74910825b260afa2c07568eecdf606e90
name: python-bonsai-prp
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Pipline result processing program for the JASEN pipeline and Bonsai tool.
url: https://pypi.org/project/bonsai-prp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bonsai-prp-0.11.1-1.src.rpm
checksum_type: sha256
description:
  *A collection of parsers and data models for creation and validation of a standardized output for the [jasen](https://github.com/genomic-medicine-sweden/jasen) pipeline which is used as an input for [bonsai](https://github.com/Clinical-Genomics-Lund/bonsai).*

  > [!WARNING]
  > Bonsai-PRP is under development in an alpha stage. Expect uneven documentation, breaking changes, and bugs until the official 1.0 release.


  * biopython
  * pydantic=2.5.3
  * python=3.10



  ```
  prp --help
  ```


  ```
  prp <method> --help
  ```


  ```
  prp create-bonsai-input -i SAMPLE_ID -u RUN_METADATA_FILE -q QUAST_FILENAME -d PROCESS_METADATA_FILE -k KRAKEN_FILE -a AMRFINDER_FILE -m MLST_FILE -c CGMLST_FILE -v VIRULENCEFINDER_FILE -r RESFINDER_FILE -p POSTALIGNQC_FILE -k MYKROBE_FILE -t TBPROFILER_FILE --vcf VCF_FILE [--snv-vcf SNV_VCF_FILE] [--sv-vcf SV_VCF_FILE] [--symlink-dir SYMLINK_DIR] [--correct_alleles] -o OUTPUT_FILE [-h]
  ```


  ```
  prp create-cdm-input -q QUAST_FILENAME -c CGMLST_FILE -p POSTALIGNQC_FILE [--correct_alleles] -o OUTPUT_FILE [-h]
  ```


  ```
  prp create-qc-result -i SAMPLE_ID --b BAM_FILE [-e BED_FILE] [-a BAITS_FILE] -r REFERENCE_FILE [-c CPUS] -o OUTPUT_FILE [-h]
  ```


  ```
  prp rerun-bonsai-input -i INPUT_DIR  -j JASEN_DIR -s SYMLINK_DIR -o OUTPUT_DIR -o OUTPUT_FILE [-h]
  ```


  ```
  prp add-igv-annotation-track -n TRACK_NAME -a ANNOTATION_FILE -b BONSAI_INPUT_FILE -o OUTPUT_FILE [-h]
  ```


  ```
  prp validate -o OUTPUT_FILE [-h]
  ```


pkgId: 1209e97338475fa732676fb86eeebd7e8cd85358779ee6e288942d48d063c22d
name: python-bookchain
arch: src
version: 0.2.2
epoch: 0
release: 1
url: https://github.com/k98kurz/bookchain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bookchain-0.2.2-1.src.rpm
checksum_type: sha256
summary:
  Double-entry accounting system with cryptographic audit trail and optional cryptographic transaction verification.

description:
  BookChain is an accounting library that provides a cryptographic audit trail of
  every identity, ledger, account, transaction, and entry to ensure data
  integrity. It also uses the tapescript package to ensure account security and
  reject invalid transactions if controls are configured on the involved accounts.
  Included are tools for establishing correspondent credit relations as well as
  accomplishing basic bookkeeping tasks.

  This package uses
  [sqloquent](https://pypi.org/project/sqloquent) for database persistence,
  [tapescript](https://pypi.org/project/tapescript) for authorization, and
  [packify](https://pypi.org/project/packify) for deterministic encoding.



  All initially planned features have been implemented and tested.

  Open issues can be found [here](https://github.com/k98kurz/bookchain/issues).

  The async implementation has an upstream issue from the sqloquent dependency
  that can be tracked [here](https://github.com/k98kurz/sqloquent/issues/16). Once
  that is fixed, the dependency will be updated, and this notice will be removed.



  This library provides an accounting system using sqloquent for persistence,
  packify for deterministic encoding, tapescript for authorization, and the
  classic rules of double-entry bookkeeping. All entries and transactions have
  deterministic content IDs determined by hashing the relevant contents, and the
  inclusion of tapescript allows for Bitcoin-style locking and unlocking scripts
  to encode access controls at the account level.



  `Currency` represents a currency/unit of account for a `Ledger`. It includes the
  number of subunits to track and optionally the base for conversion to decimal
  (defaults to 10), FX symbol, prefix symbol, and/or postfix symbol to be used with
  the `format` method (e.g. `USD.format(1200)` could result in "12.00 USD",
  "$12.00", or "12.00$", respectively). It also includes `to_decimal` method for
  formatting int amounts into `Decimal`s, and `get_units` method for getting a
  tuple of whole units and remainders.

  `Identity` represents a legal person or other entity that can sign contracts
  or engage in transactions. It includes the name, details, and optionally public
  key bytes and private key seed bytes.

  `Ledger` represents a general ledger for a given `Identity` using a specific
  `Currency`. It includes a name, a `LedgerType`, the `Identity` id, and the
  `Currency` id. `LedgerType` is an enum representing the valid ledger types,
  either `PRESENT` or `FUTURE` for cash and accrual accounting, respectively, or
  for other uses the package user may define.

  `Account` represents an account for a given `Ledger`. It includes a name, a type
  (one of the `AccountType` enum options), the `Ledger` id, an optional locking
  script for access control, and optional details.

  `AccountCategory` represents a category for `Account`s. It includes a name, a
  `LedgerType`, and a destination (str description; e.g. "Balance Sheet" or
  "Profit and Loss").

  `AccountType` is an enum representing the valid account types. The options are
  `DEBIT_BALANCE`, `ASSET`, `CONTRA_ASSET`, `CREDIT_BALANCE`, `LIABILITY`,
  `EQUITY`, `CONTRA_LIABILITY`, and `CONTRA_EQUITY`.

  `Entry` represents an entry in the general ledger for a given `Account`. It
  includes a type (one of the `EntryType` enum options), an amount, a nonce, the
  `Account` id, and optional details.

  `EntryType` is an enum representing the valid entry types. The options are
  CREDIT and DEBIT.

  `Transaction` represents a transaction made of `Entry`s. It includes the `Entry`
  ids, `Ledger` ids, a timestamp, details, and the auth script(s). Each
  `Transaction` must include entries that balance the number of credits and debits
  applied to each ledger affected by the transaction. Use `Transaction.prepare` to
  prepare a transaction -- it will raise validation errors if the transaction is
  not valid -- then call `.save()` on the result to persist it to the database.
  Transactions in the database can be validated by using `.validate()`, which will
  return `True` if it is valid and `False` if it is not (it will also raise errors
  in some situations that require more information about the validation failure).

  `Correspondence` represents a correspondent credit relationship between several
  `Identity`s.

  - `Identity` has many `Ledger`s and is within `Correspondence`s
  - `Ledger` belongs to `Identity` and `Currency`, has many `Account`s, and is within `Transaction`s
  - `Account` belongs to `Ledger` and `AccountCategory`, and has many `Entry`s
  - `AccountCategory` has many `Account`s
  - `Entry` belongs to `Account` and is within `Transaction`s
  - `Transaction` contains `Ledger`s and `Entry`s
  - `Correspondence` contains `Identity`s



  Models inherit from `sqloquent.HashedModel`, so all data is hashed into the ID,
  guaranteeing a unique, deterministic ID for each unique model.

  Whenever something is deleted, it will be encoded and inserted into the
  `deleted_models` table to maintain an audit trail.

  Accounts may be created with locking scripts, which will require associated
  Entries to provide valid auth scripts. These scripts are executed using
  tapescript. If some tapescript runtime values are required for validation,
  e.g. cache or plugins, they can be saved in Transaction.details and passed to
  `Transaction.validate` and `Account.validate_script`.



  Install with `pip install bookchain`. If you want to use the async version,
  instead install with `pip install bookchain[asyncql]`.

  Once installed, use the following to setup your project as appropriate:

  ```python
  import bookchain

  bookchain.publish_migrations(folder_for_migration_files)

  bookchain.automigrate(folder_for_migration_files, db_file_path)

  bookchain.set_connection_info(db_file_path)
  ```

  To use the async version:

  ```python
  import bookchain
  import bookchain.asyncql

  bookchain.publish_migrations(folder_for_migration_files)

  bookchain.automigrate(folder_for_migration_files, db_file_path)

  bookchain.asyncql.set_connection_info(db_file_path)
  ```



  Documentation generated by [autodox](https://pypi.org/project/autodox) can be
  found [here](https://github.com/k98kurz/bookchain/blob/v0.2.2/dox.md). Docs for
  the async version can be found
  [here](https://github.com/k98kurz/bookchain/blob/v0.2.2/asyncql_dox.md).

  Check out the [Pycelium discord server](https://discord.gg/b2QFEJDX69). If you
  experience a problem, please discuss it on the Discord server. All suggestions
  for improvement are also welcome, and the best place for that is also Discord.
  If you experience a bug and do not use Discord, open an issue on Github.



  There are a total of 12 tests (6 e2e tests and 6 tests for miscellaneous
  tools/features). To run them, clone the repo, set up a virtual environment
  (e.g. `python -m venv venv && source venv/bin/activate`), install the
  dependencies with `pip install -r requirements.txt`, and then run the following:
  `find tests -name test_*.py -print -exec python {} \;`. On Windows, the 7 test
  files will have to be individually run with the following:

  ```bash
  python tests/test_advanced_e2e.py
  python tests/test_async_advanced_e2e.py
  python tests/test_async_basic_e2e.py
  python tests/test_async_correspondences_e2e.py
  python tests/test_basic_e2e.py
  python tests/test_correspondences_e2e.py
  python tests/test_misc.py
  ```



  Copyright (c) 2024 Jonathan Voss (k98kurz)

  Permission to use, copy, modify, and/or distribute this software
  for any personal, non-commercial purpose is hereby granted, provided
  that the above copyright notice and this permission notice appear in
  all copies. For other uses, contact the software author.

  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

rpm_license:
  Copyright (c) 2024 Jonathan Voss (k98kurz)  Permission to use, copy, modify, and/or distribute this software for any personal, non-commercial purpose is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. For other uses, contact the software author.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 6e004913cafca3d4d48421725692d78e675f05713405507040c0f52d2f32719f
name: python-bookiesports
arch: src
version: 0.4.18
epoch: 0
release: 1
summary: Sports module for bookied
url: http://pbsa.info
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bookiesports-0.4.18-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/v/bookiesports.svg?style=for-the-badge)
  ![](https://img.shields.io/github/downloads/pbsa/bookiesports/total.svg?style=for-the-badge)
  ![](https://img.shields.io/pypi/pyversions/bookiesports.svg?style=for-the-badge)

  [![docs master](https://readthedocs.org/projects/bookiesports/badge/?version=latest)](http://bookiesports.rtfd.io/en/latest/)

  `bookiesports` is a module that contains the management information for
  BOS. This management information describes which sports are supported,
  which leagues and participants are available and how and what betting
  markets are created and resolved.



  [![docs master](https://readthedocs.org/projects/bookiesports/badge/?version=latest)](http://bookiesports.rtfd.io/en/latest/)


pkgId: 3285287ab443b95e19749f297406b6ff888ca9c88501a33d54b370355c3e1604
name: python-booking-pdf-generator-vipin247
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A small example package
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-booking-pdf-generator-vipin247-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A Python library for generating booking confirmation PDFs.



  ```bash
  pip install booking-pdf-generator


pkgId: fb1a903a16bff998b3240a6c8a6e352b7180e7fce2bbf845e00f7b10740f1f5a
name: python-bookmarks-converter
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Convert browser bookmarks files.
url: https://github.com/radam9/bookmarks-converter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bookmarks-converter-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/github/actions/workflow/status/radam9/bookmarks-converter/build-deploy.yml?branch=main&style=flat-square)](https://github.com/radam9/bookmarks-converter)
  [![image](https://img.shields.io/github/license/radam9/bookmarks-converter?style=flat-square)](https://pypi.org/project/bookmarks-converter/)
  [![image](https://img.shields.io/pypi/pyversions/bookmarks-converter?style=flat-square)](https://pypi.org/project/bookmarks-converter/)
  BookmarksConverter is a package that converts browser bookmark files, usable as a [`module`](#usage-as-module) or as a [CLI](#usage-as-cli).
  BookmarksConverter supports the converters below:
  - Bookmarkie (custom formats)
  - Chrome/Chromium
  - Firefox
  The converters can import and export bookmarks from and to the formats listed below:
  - Bookmarkie: `DB`, `HTML`, `JSON`
  - Chrome/Chromium: `HTML`, `JSON`
  - Firefox: `HTML`, `JSON`
  Notes:
  - Supports Netscape-Bookmark format for `HTML` files
  - The exported `HTML` files are compatible with all browsers.
  - Custom `DB` files are powered by SQLAlchemy ORM (see [`models.py`](/src/bookmarks_converter/models.py)).
  - Chrome/Chromium `JSON` files cannot be directly imported but can be placed in the appropriate location (see [bookmarks_file_structure.md - Chrome/Chromium - b. JSON](./bookmarks_file_structure.md#b-json)).
  - For examples of supported `DB`, `HTML`, or `JSON` structures and formats, refer to the [test resources](tests/resources) or [bookmarks_file_structure.md](bookmarks_file_structure.md).


pkgId: 4bb1d3551aaee3a2271eab5f4231665864f9ae9dd7aaf7af889d3973f9a3877a
name: python-bookops-worldcat
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: OCLC WorldCat Metadata APIs wrapper
url: https://bookops-cat.github.io/bookops-worldcat/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bookops-worldcat-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/BookOps-CAT/bookops-marc/actions/workflows/unit-tests.yaml/badge.svg?branch=main)](https://github.com/BookOps-CAT/bookops-worldcat/actions) [![Coverage Status](https://coveralls.io/repos/github/BookOps-CAT/bookops-worldcat/badge.svg?branch=main)](https://coveralls.io/github/BookOps-CAT/bookops-worldcat?branch=main) [![PyPI version](https://badge.fury.io/py/bookops-worldcat.svg)](https://badge.fury.io/py/bookops-worldcat) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bookops-worldcat) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  BookOps-Worldcat provides a Python interface for the WorldCat Metadata API. This wrapper simplifies requests to OCLC web services making them more accessible to OCLC member libraries.

  Bookops-Worldcat version 1.0 supports changes released in version 2.0 (May 2023) of the OCLC Metadata API.



  Use pip:

  `$ pip install bookops-worldcat`



  For full documentation please see https://bookops-cat.github.io/bookops-worldcat/



  Bookops-Worldcat takes advantage of the functionality of the popular [Requests library](https://requests.readthedocs.io/) and interactions with OCLC's services are built around 'Requests' sessions. `MetadataSession` inherits all `requests.Session` properties. Server responses are `requests.Response` objects with [all of their properties and methods](https://requests.readthedocs.io/en/latest/user/quickstart/).

  Authorizing a web service session simply requires passing an access token to `MetadataSession`. Opening a session allows the user to call specific methods to facilitate communication between the user's script/client and a particular endpoint of the Metadata API. Many of the hurdles related to making valid requests are hidden under the hood of this package, making it as simple as possible.

  BookOps-Worldcat supports requests to all endpoints of the WorldCat Metadata API 2.0 and Authentication using the [Client Credential Grant](https://www.oclc.org/developer/api/keys/oauth/client-credentials-grant.en.html) flow:

  + [Authentication via Client Credential Grant](https://www.oclc.org/developer/api/keys/oauth/client-credentials-grant.en.html)
  + [Worldcat Metadata API](https://www.oclc.org/developer/api/oclc-apis/worldcat-metadata-api.en.html)
      + Manage Bibliographic Records
      + Manage Institution Holdings
      + Manage Local Bibliographic Data
      + Manage Local Holdings Records
      + Search Member Shared Print Holdings
      + Search Member General Holdings
      + Search Bibliographic Resources
      + Search Local Holdings Resources
      + Search Local Bibliographic Resources



  Authorizing a MetadataSession
  ```python
  from bookops_worldcat import WorldcatAccessToken
  token = WorldcatAccessToken(
      key="my_WSKey",
      secret="my_secret",
      scopes="WorldCatMetadataAPI",
  )
  print(token)

  print(token.is_expired())

  ```

  Search for brief bibliographic resources
  ```python
  with MetadataSession(authorization=token) as session:
      response = session.brief_bibs_search(q="ti:The Power Broker AND au: Caro, Robert")
      print(response.json())
  ```
  ```json
  {
    "numberOfRecords": 89,
    "briefRecords": [
      {
        "oclcNumber": "1631862",
        "title": "The power broker : Robert Moses and the fall of New York",
        "creator": "Robert A. Caro",
        "date": "1975",
        "machineReadableDate": "1975",
        "language": "eng",
        "generalFormat": "Book",
        "specificFormat": "PrintBook",
        "edition": "Vintage Books edition",
        "publisher": "Vintage Books",
        "catalogingInfo": {
          "catalogingAgency": "DLC",
          "catalogingLanguage": "eng",
          "levelOfCataloging": " ",
          "transcribingAgency": "DLC"
        }
      }
    ]
  }
  ```
  MetadataSession as Context Manager:
  ```python
  with MetadataSession(authorization=token) as session:
      result = session.bib_get("1631862")
      print(result.text)
  ```
  ```xml
  <?xml version='1.0' encoding='UTF-8'?>
    <record xmlns="http://www.loc.gov/MARC21/slim">
      <leader>00000cam a2200000 i 4500</leader>
      <controlfield tag="001">ocm01631862</controlfield>
      <controlfield tag="003">OCoLC</controlfield>
      <controlfield tag="005">20240201163642.4</controlfield>
      <controlfield tag="008">750320t19751974nyuabf   b    001 0beng  </controlfield>
      <datafield tag="010" ind1=" " ind2=" ">
        <subfield code="a">   75009557 </subfield>
      </datafield>
  <!--...-->
      <datafield tag="020" ind1=" " ind2=" ">
        <subfield code="a">9780394720241</subfield>
        <subfield code="q">(paperback)</subfield>
  <!--...-->
      <datafield tag="100" ind1="1" ind2=" ">
        <subfield code="a">Caro, Robert A.,</subfield>
        <subfield code="e">author.</subfield>
      </datafield>
      <datafield tag="245" ind1="1" ind2="4">
        <subfield code="a">The power broker :</subfield>
        <subfield code="b">Robert Moses and the fall of New York /</subfield>
        <subfield code="c">by Robert A. Caro.</subfield>
      </datafield>
      <datafield tag="246" ind1="3" ind2="0">
        <subfield code="a">Robert Moses and the fall of New York</subfield>
      </datafield>
      <datafield tag="250" ind1=" " ind2=" ">
        <subfield code="a">Vintage Books edition.</subfield>
      </datafield>
      <datafield tag="264" ind1=" " ind2="1">
        <subfield code="a">New York :</subfield>
        <subfield code="b">Vintage Books,</subfield>
        <subfield code="c">1975.</subfield>
      </datafield>
  <!--...-->
  </record>
  ```



  New functionality available in version 1.0:

  + Send requests to all endpoints of WorldCat Metadata API
      + Match bib records and retrieve bib classification
      + Create, update, and validate bib records
      + Create, retrieve, update, and delete local bib and holdings records
  + Add automatic retries to failed requests
  + Authenticate and authorize for multiple institutions within `MetadataSession`
  + Support for Python 3.11 and 3.12
  + Dropped support for Python 3.7


  Bookops-Worldcat 1.0 introduces many breaking changes for users of previous versions. Due to a complete refactor of the Metadata API, the methods from Bookops-Worldcat 0.5.0 have been rewritten. Most of the functionality from previous versions of the Metadata API is still available in Version 2.0. For a comparison of the functionality available in Versions 1.0, 1.1, and 2.0 of the Metadata API, see [OCLC's documentation](https://www.oclc.org/developer/api/oclc-apis/worldcat-metadata-api.en.html) and their [functionality comparison table](https://www.oclc.org/content/dam/developer-network/worldcat-metadata-api/worldcat-metadata-api-functionality-comparison.pdf).

  Versions 1.0 and 1.1 of the Metadata API will be sunset after April 30, 2024 at which point tools that rely on Bookops-Worldcat 0.5 will no longer be able to query the Metadata API.

  For more information on changes made in Version 1.0, see [Features in Version 1.0](https://bookops-cat.github.io/bookops-worldcat/latest/#features-in-version-1.0) in the docs.



  Consult the [Changelog page](https://bookops-cat.github.io/bookops-worldcat/latest/changelog/) for a full list of fixes and enhancements for each version.



  Please use the [Github issue tracker](https://github.com/BookOps-CAT/bookops-worldcat/issues) to submit bugs or request features.



  See [Contribution Guidelines](https://bookops-cat.github.io/bookops-worldcat/latest/contributing) for information on how to contribute to bookops-worldcat.


pkgId: a8b7c80eecf9de8d075d760d562130c9b6c860b0ab9d130b27e9ee0135279445
name: python-bookserver
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: A new Runestone Server Framework
url: https://pypi.org/project/bookserver/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bookserver-1.5.1-1.src.rpm
checksum_type: sha256
description:
  *******************************************
  New FastAPI-based Book Server for Runestone
  *******************************************
  The BookServer is a next-generation server for the `Runestone platform <https://runestone.academy/>`_. The goal of this project is to replace the parts of the web2py-based RunestoneServer. For more information, see the `full documentation <https://bookserver.readthedocs.io/en/latest/>`_.

  We would love development help on this; see the `developer docs <https://bookserver.readthedocs.io/en/latest/docs/dev_toctree.html>`_.

  TODO: A nice image of a book or something eye-catching.


pkgId: 6a75d95083938ad2f598828546bbd8e3ded7968dcfd53a6e6c60cf73fc83fe30
name: python-booktest
arch: src
version: 0.3.40
epoch: 0
release: 1
summary: Booktest is a snapshot testing library for review driven testing.
url: https://github.com/lumoa-oss/booktest
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-booktest-0.3.40-1.src.rpm
checksum_type: sha256
description:
  booktest is review-driven testing tool that combines Jupyterbook style data science
  development with traditional regression testing. Booktest is developed by
  [Lumoa.me](https://lumoa.me), the actionable feedback analytics platform.

  booktest is designed to tackle a common problem with the data science
  RnD work flows and regression testing:

   * Data science produces results such as probability estimates, which can be
     good or bad, but not really right or wrong as in the traditional software engineering.
       * Because the DS results are not strictly right or wrong, it's very difficult to use assertions
         for quality assurance and preventing regression.
       * For example, you cannot really say that accuracy 0.84 is correct, while the
         accuracy 0.83 is incorrect, especially if you have other measurements (log likelihood)
         giving conflicting results. Neither evaluating a topic model as correct or incorrect
         is non-sensical. In practice, most data science applications require an expert
         review.
       * This less ambigious quality also creates need for a better visibility of how
         the system behaves. One typically wants to print out edge cases and their diagnostics
         to see the behavior, see intermediate steps and see the results for different data sets .
   * There is also the problem of the data science data being big and the intermediate
     results being computationally expensive.
       * Jupyter notebook deals with this problem by keeping the state in memory between runs, while
         traditional unittests tend to lose the program state between runs. This leads to very slow
         test runs, slow iteration speed and low productivity.
   * While the Jupyter Notebook provides good visibility to results required by the expert review and
     powerful caching functionality: it fails short on a) often requiring copy-pasting production code to
     make results visible, b) it doesn't support automated regression testing and c) expert review requires
     expensive full review even if nothing changed.

  booktest solves this problem setting by delivering on 3 main points:

   * Focus on the results and analytic as in Jupyter notebook by allowing user to print
     the results as MD files.
   * Keep the intermediate results cached either in memory or in filesystem by
     having two level cache.
   * Instead of doing strict assertions, do testing by comparing old results with
     new results.

  As such, booktest does snapshot testing, and it stores the snapshots in filesystem and in Git.
  Additional benefit of this approach is that you can trace the result development in Git.



  You can find getting started guide [here](getting-started.md)



  You can find guide on common workflows, coverage measurements and
  continuous integration [here](workflows.md)



  Examples are found in the [test example directory](test/examples).

  Example results are visible in the [book index](books/index.md).

  There is also [separate example project](https://github.com/lumoa-oss/booktest-example)




  API reference is generated under [docs](docs) directory. Main classes are:

   * [TestCaseRun](docs/testcaserun.py.md), which provides API for tests
   * [TestBook](docs/testbook.py.md), which provide a base class for test suite object
   * [TestSuite](docs/testsuite.py.md), which provide a base class for test suite object
   * [Tests](docs/tests.py.md), which manages CLI interface



  Development guide is available [here](development.md)


pkgId: ab7fd79451d67736836d980763b7d03a82bf5fc9ca2f542a5cf54b8502a6615e
name: python-boolean-parser
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Package for parsing strings containing conditional boolean logic
url: https://github.com/havok2063/boolean_parser
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boolean-parser-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/havok2063/boolean_parser.svg?branch=master)](https://travis-ci.com/havok2063/boolean_parser)
  [![Documentation Status](https://readthedocs.org/projects/boolean-parser/badge/?version=latest)](https://boolean-parser.readthedocs.io/en/latest/?badge=latest)
  ![Python application](https://github.com/havok2063/boolean_parser/workflows/Python%20application/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/havok2063/boolean_parser/badge.svg?branch=master)](https://coveralls.io/github/havok2063/boolean_parser?branch=master)
  [![codecov](https://codecov.io/gh/havok2063/boolean_parser/branch/master/graph/badge.svg)](https://codecov.io/gh/havok2063/boolean_parser)


  Python package for parsing a string with conditional expressions joined with boolean logic.  Uses the [pyparsing](https://github.com/pyparsing/pyparsing) package to construct grammatical clauses representing conditional expression, e.g. "x > 1 and y < 2".  String conditional expressions can then be parsed into object representation to be handled downstream.  Can
  convert string boolean expressions into SQLAlchemy filter conditions.

  Documentation: https://boolean-parser.readthedocs.io/en/latest/

  Parsers:
   - Parser: core parser for handling parsing complex boolean conditional expressions
   - SQLParser: parser that enables converting a string conditional into a SQLAlchemy filter clause


pkgId: 52aa67016c8c707e7cfd1c1a532c3d9f67b108d03343ed08e001971598b4232a
name: python-boolean.py
arch: src
version: 4.0
epoch: 0
release: 1
summary: Define boolean algebras, create and parse boolean expressions and create custom boolean DSL.
url: https://github.com/bastikr/boolean.py
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boolean.py-4.0-1.src.rpm
checksum_type: sha256
description:
  This library helps you deal with boolean expressions and algebra with variables
  and the boolean functions AND, OR, NOT.

  You can parse expressions from strings and simplify and compare expressions.
  You can also easily create your custom algreba and mini DSL and create custom
  tokenizers to handle custom expressions.

  For extensive documentation look either into the docs directory or view it online, at
  https://booleanpy.readthedocs.org/en/latest/

  https://github.com/bastikr/boolean.py

  Copyright (c) 2009-2020 Sebastian Kraemer, basti.kr@gmail.com and others
  SPDX-License-Identifier: BSD-2-Clause


pkgId: 47d66c51b7f6556c572373bbb2af4edfc221ffefa70f9cc38200008a3b96da21
name: python-booleanOperations
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Boolean operations on paths.
url: https://github.com/typemytype/booleanOperations
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-booleanOperations-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Boolean operations on paths which uses a super fast `polygon clipper
  library by Angus Johnson <http://www.angusj.com/delphi/clipper.php>`__.
  You can download the latest version from PyPI:
  https://pypi.org/project/booleanOperations.


pkgId: ce6a93c5e905609b96ace67e66373fdc420df003b0e3c3f679465d47689c3efd
name: python-boolexpr
arch: src
version: 2.4
epoch: 0
release: 1
summary: Boolean Expressions
url: http://www.boolexpr.org
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boolexpr-2.4-1.src.rpm
checksum_type: sha256
description:
  This code is known to compile on Ubuntu Trusty Linux.
  Install the following dependencies::
      sudo apt-get install -y build-essential cmake doxygen


pkgId: 8fa1a98b10001cd19cbc38cbabfa2534ae61390b1ef9427af3f1d10175f4d8b3
name: python-boonamber
arch: src
version: 2.0.16
epoch: 0
release: 1
summary: An SDK for Boon Amber sensor analytics
url: https://pypi.org/project/boonamber/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boonamber-2.0.16-1.src.rpm
checksum_type: sha256
description:
  ![Logo](https://github.com/boonlogic/amber-python-sdk/blob/master/docs/BoonLogic.png?raw=true)



  - __Version 1__: [Boon Amber Version 1](https://boonlogic.github.io/amber-python-sdk/boonamber/v1)
  - __Version 2__: [Boon Amber Version 2](https://boonlogic.github.io/amber-python-sdk/boonamber/v2)


pkgId: 35f5ef00e675ada8626e76de358371d3b5598a7c53a9ed8ce70e3eafae177a52
name: python-boostedblob
arch: src
version: 0.15.4
epoch: 0
release: 1
url: https://pypi.org/project/boostedblob/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boostedblob-0.15.4-1.src.rpm
checksum_type: sha256
summary:
  Command line tool and async library to perform basic file operations on local paths, Google Cloud Storage paths and Azure Blob Storage paths.

description:
  boostedblob is a command line tool and async library to perform basic file operations on local
  paths, Google Cloud Storage paths and Azure Blob Storage paths.

  boostedblob is derived from the excellent [blobfile](https://github.com/christopher-hesse/blobfile).

  The fun part of implementing boostedblob is `boostedblob/boost.py`, which provides a
  `concurrent.futures`-like interface for running and composing async tasks in a concurrency limited
  environment.



  Just run `pip install boostedblob`. boostedblob requires Python 3.8 or better.



  For an overview and list of commands:
  ```sh
  bbb --help
  ```

  For help with a specific command:
  ```sh
  bbb ls --help
  ```

  To enable tab completion, add the following to your shell config (replacing `zsh` with `bash`,
  if appropriate):
  ```sh
  eval "$(bbb complete init zsh)"
  ```
  Note that the quotes are necessary. You can also inline the result of `bbb complete init zsh` into
  your shell config to make your shell startup a little faster.



  For developer documentation (getting started, running tests, debugging tricks, codebase tips),
  see [CONTRIBUTING.md](CONTRIBUTING.md)


pkgId: 9e4528be91876f03c7ff0ef46d92d144432a2d0114b02a19e610388509caf43e
name: python-boosty
arch: src
version: 0.0.29
epoch: 0
release: 1
summary: Asynchronous boosty wrapper with some utils
url: https://pypi.org/project/boosty/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boosty-0.0.29-1.src.rpm
checksum_type: sha256
description:
  **[Описание на русском](https://github.com/barsikus007/boosty/blob/master/README-ru.md)**
  **Table of Contents**
  - [Installation](#installation)
  - [License](#license)
  - [Usage](#usage)

  ```console
  pip install boosty
  ```

  `boosty` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
  > [!IMPORTANT]
  > **!WARNING! this version of library is very unstable**
  >
  > **If you use it, contact maintainer to help make it stable**

  *Optional:* specify `IGNORE_MISSING_AND_EXTRA_FIELDS` environment variable to disable strict schema validation
  ```py

  import os
  os.environ["IGNORE_MISSING_AND_EXTRA_FIELDS"] = "true"
  ```
  *Optional:* fill `auth.json` file with authentication data (or use [browser auth](https://github.com/barsikus007/boosty/blob/master/examples/browser_auth.py) to create them):
  ```json
  {
    "access_token": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
    "device_id": "ffffffff-ffff-ffff-ffff-ffffffffffff",
    "expires_at": 12345678900,
    "refresh_token": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
  }
  ```
  Example:
  ```python
  import asyncio
  from boosty.api import API
  async def main():
      api = API()
      response = await api.get_post("boosty", post_id="c9fb8a19-c45e-4602-9942-087c3af28c1b")
      print(response.title)
      
  asyncio.run(main())
  ```
  More examples in [examples/](https://github.com/barsikus007/boosty/tree/master/examples/) folder

  - inject additional data to models from requests
  - convert timestamps to datetime
    - serialize it to int when dumping
  - schema
    - complete api schema (at 100 stars)
      - add access levels logic for requests
    - more useful properties for models
    - merge reply comment with comment model
    - msgspec?
    - rename folder types/ to schema/
  - logic
    - get rid of strange pydantic model init depends on env
    - maybe better solution for auth data storage
  - docs/ (at 50 stars)
  - examples/
    - render text
    - get video url
    - get comment url
  - tests/
    - boosty profile
    - test posts under my account
    - comments
    - replies
    - video
    - entities parsing
  - create dev branch


pkgId: 4c1292a00a4388d0240452c568c8a88562a86014aaafb1f2477cb5bff4cb3910
name: python-bootstrap-rag
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bootstrap-rag/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bootstrap-rag-0.0.14-1.src.rpm
checksum_type: sha256
description:
  ![Banner](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/bootstrap-rag.png)

  This project will bootstrap and scaffold the projects for specific semantic search and RAG applications along with regular boilerplate code.


  ![Arch](assets/architecture.png)




  - install ollama following this [guide](https://ollama.com/download)
  - install qdrant follwing this [guide](https://qdrant.tech/documentation/guides/installation/)


  - In the root folder run `docker compose -f docker-compose-dev.yml up`
  - One the containers are up and running run `docker exec -it ollama_service sh`
  - In the container shell run `ollama run llama3.1`



  - run `pip install inquirerpy bootstrap-rag`
  - run `bootstraprag create <PROJECT_NAME>`
  - Navigate to newly created project `<PROJECT_NAME>` the run `pip install -r requirements.txt`
  - modify the `.env` file accordingly
  - run `python main.py` for cli experience
    <b>[or]</b> run `python api_server.py`


  - `git clone git@github.com:pavanjava/bootstrap-rag.git`
  - `pip install -e .`
  - run `bootstraprag create <PROJECT_NAME>`
  - Navigate to newly created project `<PROJECT_NAME>` the run `pip install -r requirements.txt`
  - modify the `.env` file accordingly
  - run `python main.py` for cli experience
    <b>[or]</b> run `python api_server.py`


  Note: `llamaindex`, `langchain`, `Qdrant Search` and `RAG evaluations` are functional for now, others frameworks [`langgraph`, `haystack`] in progress.



  ![Demo GIF](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/demo.gif)

  ![Qdrant](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/qdrant.png)

  ![Arize Phoenix](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/observability.png)


pkgId: 3abda63cf98ad6e32e2740962ee3d417112a88a015888b2221ce5e74816f9459
name: python-bootstrapped
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Implementations of the percentile based bootstrap
url: https://github.com/facebookincubator/bootstrapped
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bootstrapped-0.0.2-1.src.rpm
checksum_type: sha256
description:
  **bootstrapped** is a Python library that allows you to build confidence
  intervals from data. This is useful in a variety of contexts - including
  during ad-hoc a/b test analysis.


pkgId: 9f569467fc870b408053718e4bc85b72f630abbb7dd5667a658c12972b590aa7
name: python-bootstrapping-tools
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: GECI Tools for bootstrapping
url: https://github.com/IslasGECI/bootstrapping_tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bootstrapping-tools-3.2.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://www.islas.org.mx/"><img src="https://www.islas.org.mx/img/logo.svg" align="right" width="256" /></a>



  GECI tools to perform bootstrapping sampling by blocks.


pkgId: 88a274b103d7ba29f7d846538c8c7b358b587b871050c05eef2c9efb80c6c634
name: python-bootwrap
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Package for rapid development of web-based user interfaces.
url: https://github.com/mmgalushka/bootwrap
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bootwrap-1.2.0-1.src.rpm
checksum_type: sha256
description:
  ![Python + Bootstrap = Bootwrap](https://github.com/mmgalushka/bootwrap/raw/main/docs/bootwrap-equation.png)

  [![Continuous Integration Status](https://github.com/mmgalushka/bootwrap/workflows/CI/badge.svg)](https://github.com/mmgalushka/bootwrap/actions)
  [![Code Coverage Percentage](https://codecov.io/gh/mmgalushka/bootwrap/branch/main/graphs/badge.svg)](https://codecov.io/gh/mmgalushka/bootwrap)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/763657a471ff424c85a5b894ddb750d0)](https://www.codacy.com/gh/mmgalushka/bootwrap/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=mmgalushka/bootwrap&amp;utm_campaign=Badge_Grade)
  [![Project License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/mmgalushka/bootwrap/blob/main/LICENSE)
  [![Project Documentation](https://img.shields.io/badge/docs-up--to--date-success)](https://mmgalushka.github.io/bootwrap/)

  **Bootwrap** is a Python library for rapid developing of web-based user interfaces (WebUI). It helps creating WebUI using Python code only and can be used in conjunction with different web-development frameworks such as [Flask](https://palletsprojects.com/p/flask/). Under the hood, this library wraps one of the most popular front-end toolkit [Bootstrap](https://getbootstrap.com/).

  As a showcase of what this library is capable of please check the documentation. The entire [documentation](https://mmgalushka.github.io/bootwrap/) web interface is created using the **Bootwrap**.



  Install and update using [pip](https://pip.pypa.io/en/stable/quickstart/):

  ```bash
  ~$ pip install bootwrap
  ```

  Bootwrap package has no external dependencies!



  The vast majority of web applications consist of frontend and backend. If you are a small team or even a solo developer you need to divide resources and time to focus on both parts. This often results in switching between different platforms such as Python and [React](https://reactjs.org/), [AngularJs](https://angular.io/), Flask templates (HTML, CSS, JS), etc. But what if your main focus is the backend and you also don't want to compromise on the quality of your WebUI. In this case, the Bootwrap library is for you! It will help you develop WebUI without leaving the Python ecosystem and not waste your time on HTML, CSS, and Javascript. To understand its capability just clone the project and run the [demo application](demo/demo.md) ":pig: PiggyBank".

  ![Screenshots Collage](demo/collage.png)

  For more information also read the Bootwrap [documentation](https://mmgalushka.github.io/bootwrap/).



  The following code will create three pages application with a top-level menu bar for navigations. Since this application is based on [Flask](https://palletsprojects.com/p/flask/) make sure that you installed it as well.

  ```Python
  from flask import Flask
  from markupsafe import Markup
  from bootwrap import Page, Menu, Image, Anchor, Button, Text

  app = Flask(__name__, static_folder='docs', static_url_path='')

  LOGO = 'https://github.com/mmgalushka/bootwrap/blob/main/docs/logo.png?raw=true'
  FAVICON = 'https://raw.githubusercontent.com/mmgalushka/bootwrap/main/docs/favicon.ico'

  class MyMenu(Menu):
      def __init__(self):
          super().__init__(
              logo=Image(LOGO, width=32, alt='Logo'),
              brand=Text('Bootwrap').as_strong().as_light().ms(2),
              anchors=[
                  Anchor('Home').link('/'),
                  Anchor('About').link('/about')
              ],
              actions=[
                  Button('Sign In').as_outline().as_light().link('/signin')
              ]
          )

  class MyPage(Page):
      def __init__(self, container):
          super().__init__(
              favicon = FAVICON,
              title='Hello World Application',
              menu=MyMenu(),
              container=container
          )

  @app.route('/')
  def home():
      return Markup(MyPage(container=Text('Home').as_heading(1)))

  @app.route('/about')
  def about():
      return Markup(MyPage(container=Text('About').as_heading(1)))

  @app.route('/signin')
  def signin():
      return Markup(MyPage(container=Text('Sign In').as_heading(1)))

  if __name__ == '__main__':
      app.run(debug=True)
  ```

  Use the following command to launch the application.

  ```bash
  $ flask run
    * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
  ```

  The result should look like.

  ![Simple Example](https://github.com/mmgalushka/bootwrap/raw/main/docs/multi-pages-app.png)



  For information on how to set up a development environment and how to make a contribution to Bootwrap, see the [contributing guidelines](CONTRIBUTING.md).



  - Documentation: [https://mmgalushka.github.io/bootwrap/](https://mmgalushka.github.io/bootwrap/)
  - PyPI Releases: [https://pypi.org/project/bootwrap/](https://pypi.org/project/bootwrap/)
  - Source Code: [https://github.com/mmgalushka/bootwrap](https://github.com/mmgalushka/bootwrap/)
  - Issue Tracker: [https://github.com/mmgalushka/bootwrap/issues](https://github.com/mmgalushka/bootwrap/)


pkgId: 567f8bbb48df894a31274f7aae72f1baa0d3c968fb74b3e78aa12a5f003f52e3
name: python-booyah
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A joyful python web framework
url: https://github.com/marceloribeiro/booyah
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-booyah-0.1.2-1.src.rpm
checksum_type: sha256
description:
  ![alt TestRunner](https://github.com/marceloribeiro/booyah/actions/workflows/tests_runner.yml/badge.svg)



  Booyah is a MVC web framework written in Python that aims to be easy to use while setting up projects quickly. It follows the convention over configuration paradigm introduced by Ruby on Rails.



  The following links detail the process of installing and setting up your first project.

  [1. Installation](https://github.com/marceloribeiro/booyah/blob/main/docs/install.md)

  [2. Getting Started](https://github.com/marceloribeiro/booyah/blob/main/docs/getting-started.md)

  [3. The Booyah Console](https://github.com/marceloribeiro/booyah/blob/main/docs/console.md)

  [4. The Booyah ORM](https://github.com/marceloribeiro/booyah/blob/main/docs/booyah-orm.md)

  [5. The MVC architecture](https://github.com/marceloribeiro/booyah/blob/main/docs/booyah-mvc.md)

  [6. Database Operations](https://github.com/marceloribeiro/booyah/blob/main/docs/database-operations.md)

  [7. Generators](https://github.com/marceloribeiro/booyah/blob/main/docs/generators.md)

  [8. Jobs](https://github.com/marceloribeiro/booyah/blob/main/docs/jobs.md)



  You can collaborate with Booyah by forking the repo and submitting a pull request. We are very early stage so any help is welcome. We do try to follow the Rails way in Python though, so please keep that in mind.

  You can visit the issues tab in github for some ideas.


pkgId: 414c5d826f57a846cbe8d6b4167803d377d7d1bec3de30a4eca82628b7472ed9
name: python-bopscrk
arch: src
version: 2.4.7
epoch: 0
release: 1
summary: Generate smart and powerful wordlists
url: https://github.com/r3nt0n/bopscrk
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bopscrk-2.4.7-1.src.rpm
checksum_type: sha256
description:
  <div id="top"></div>
  <!--
  This documentation was written using Best-README-Template by othneildrew
  https://github.com/othneildrew/
  https://github.com/othneildrew/Best-README-Template/edit/master/README.md
  Thanks dude :)
  -->



  <!-- PROJECT SHIELDS -->
  [![BlackArch package](https://repology.org/badge/version-for-repo/blackarch/bopscrk.svg)](https://repology.org/project/bopscrk/versions)
  [![Rawsec's CyberSecurity Inventory](https://inventory.raw.pm/img/badges/Rawsec-inventoried-FF5050_flat.svg)](https://inventory.raw.pm/)
  [![Packaging status](https://repology.org/badge/tiny-repos/bopscrk.svg)](https://repology.org/project/bopscrk/versions)
  ![[GPL-3.0 License](https://github.com/r3nt0n)](https://img.shields.io/badge/license-GPL%203.0-brightgreen.svg)
  ![[Python 3](https://github.com/r3nt0n)](http://img.shields.io/badge/python-3-blue.svg)
  ![[Version 2.4.6](https://github.com/r3nt0n)](http://img.shields.io/badge/version-2.4.6-orange.svg)



  <!-- PROJECT LOGO -->
  <br />
  <div align="center">
    <a href="https://github.com/r3nt0n/bopscrk">
      <img src="https://github.com/r3nt0n/bopscrk/blob/master/img/logo_raster.svg" alt="Logo" width="80" height="80">
    </a>

    <h3 align="center">bopscrk</h3>

    <p align="center">
      Generate smart and powerful wordlists for targeted attacks
      <br />
      <a href="#usage"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <a href="#about-the-project">View Demo</a>
      ·
      <a href="https://github.com/r3nt0n/bopscrk/issues">Report Bug</a>
      ·
      <a href="https://github.com/r3nt0n/bopscrk/issues">Request Feature</a>
    </p>
  </div>



  <!-- TABLE OF CONTENTS -->
  <details>
    <summary>Table of contents</summary>
    <ol>
      <li>
        <a href="#about-the-project">About the Project</a>
        <ul>
          <li><a href="#whats-new">What's new</a></li>
          <li><a href="#built-with">Built with</a></li>
        </ul>
      </li>
      <li>
        <a href="#getting-started">Getting started</a>
        <ul>
          <li><a href="#installation">Installation</a></li>
          <li><a href="#run-interactive-mode">Run interactive mode</a></li>
        </ul>
      </li>
      <li>
        <a href="#usage">Usage</a>
        <ul>
          <li><a href="#how-it-works">How it works</a></li>
          <li><a href="#tips">Tips</a></li>
          <li><a href="#advanced-usage">Advanced usage</a></li>
          <li><a href="#lyricpass">Lyricpass</a></li>
        </ul>
      </li>
      <li><a href="#roadmap">Roadmap</a></li>
      <li>
        <a href="#contributing">Contributing</a>
        <ul>
          <li><a href="#contributors">Contributors</a></li>
        </ul>
      </li>
      <li><a href="#changelist">Changelist</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#contact">Contact</a></li>
      <li><a href="#acknowledgments">Acknowledgments</a></li>
      <li><a href="#legal-disclaimer">Legal disclaimer</a></li>
    </ol>
  </details>



  <!-- ABOUT THE PROJECT -->


  <p align="center"><img src="https://github.com/r3nt0n/bopscrk/blob/master/img/bopscrk.gif" /></p>



  + **Targeted-attack wordlist creator**: introduce personal info related to target, combines every word and transforms results into possible passwords. The *lyricpass* module allows to **search lyrics related to artists** and include them to the wordlists.
  + **Customizable case** and **leet transforms**: create **custom charsets** and **transforms patterns** trough a simple **config file**.
  + **Interactive mode** and **one-line command interface** supported.
  + Included in **<a href="https://blackarch.org/">BlackArch Linux</a>** pentesting distribution and **<a href="https://inventory.raw.pm/">Rawsec's Cybersecurity Inventory</a>** since August 2019.




  + **Python 3** (secondary branch keeps Python 2.7 legacy support)
    + **requests**
    + **alive-progress**



  - **2.4.7 RELEASED** (02/09/2024): Speed and performance dramatically increased. New extensive case transform mode allows to generate all possible case transforms.

  [//]: # (<p align="center"><img src="https://github.com/r3nt0n/bopscrk/blob/master/img/progressbar_example1.gif" /></p>)

  [//]: # (<p align="center"><img src="https://github.com/r3nt0n/bopscrk/blob/master/img/progressbar_example2.gif" /></p>)

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- GETTING STARTED -->




  ```
  pip install bopscrk
  ```



  *Alternatively, if you want to clone the repo from Github instead of install it from Pypi:*

  ```
  git clone --recurse-submodules https://github.com/r3nt0n/bopscrk
  cd bopscrk
  pip install -r requirements.txt
  ```



  ```
  bopscrk -i
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>


  <!-- USAGE EXAMPLES -->

  ```

    -h, --help         show this help message and exit
    -i, --interactive  interactive mode, the script will ask you about target
    -w                 words to combine comma-separated (non-interactive mode)
    --min              min length for the words to generate (default: 4)
    --max              max length for the words to generate (default: 32)
    -c, --case         enable case transformations
    -l, --leet         enable leet transformations
    -n                 max amount of words to combine each time (default: 2)
    -a , --artists     artists to search song lyrics (comma-separated)
    -o , --output      output file to save the wordlist (default: tmp.txt)
    -C , --config      specify config file to use (default: ./bopscrk.cfg)
    --version          print version and exit

  ```

  _For more information, please refer to the [Advanced usage](#advanced-usage) section._

  <p align="right">(<a href="#top">back to top</a>)</p>


  + You have to **provide** some **words** which will act as a base.
  + The **lyricpass feature** allow to introduce **artists**. The tool will download all his **songs' lyrics** and each line will be added as a new word. By default, artist names and a word formed by the initial of word on each phrase, will be added too.
  + The tool will generate **all possible combinations** between them.
  + To generate more combinations, it will add some **common separators** (e.g. "-", "_", "."), **numbers** and **special chars** frequently used in passwords.
  + You can use **leet** and **case transforms** to increase your chances.

  [//]: # (+ You can provide **wordlists** that you have already tested against the target in order **to exclude** all this words from the resultant wordlist &#40;`-x`&#41;.)


  + Fields can be left **empty**.
  + You **can use accentuation** in your words and special chars (if you use the non-interactive mode, escape special chars like `'` and `"` with backslashes, e.g.: `bopscrk -w John,O\'hara,Doe,foo,bar`).
  + In the others field you can write **several words comma-separated**. *Example*: 2C,Flipper.
  + If you want to produce **all possible leet transformations**, enable the **recursive_leet option** in configuration file.
  + If you want to produce **all possible case transformations**, enable the **extensive_case option** in configuration file.
  + You can **select which transforms to apply on lyrics phrases** found through the **cfg file**.
  + Using the **non-interactive mode**, you should provide years in the long and short way (1970,70) to get the same result than the interactive mode.
  + You have to be careful with **-n** argument. If you set a big value, it could result in **too huge wordlists**. I recommend values between 2 and 5.
  + To provide **several artist names** through command line you should provide it **comma-separated**. *Example*: `-a johndoe,johnsmith`
  + To provide **artist names with spaces** through command line you should provide it **quotes-enclosed**. *Example*: `-a "john doe,john smith"`

  <p align="right">(<a href="#top">back to top</a>)</p>





  + In `bopscrk.cfg` file you can specify your own charsets and enable/disable options:
    + **extra_combinations** (like `(john, doe) => 123john, john123, 123doe, doe123, john123doe doe123john`) are *enabled by default*. You can disable it in the configuration file in order to get more focused wordlists.
    + **separators_chars**: characters to use in extra-combinations. *Can be a single char or a string of chars, e.g.: `!?-/&(`*
    + **separators_strings**: strings  to use in extra-combinations. *Can be a single string or a list of strings space-separated, e.g.: `123` `34!@`*
    + **leet_charset**: characters to replace and correspondent substitute in leet transforms, *e.g.: `e:3 b:8 t:7 a:4`*
    + **recursive_leet**: enables a recursive call to leet_transforms() function to get all possible leet transforms. *WARNING*: enabled with huge `--max` values (e.g.: greater than 18) could take a long time. *Can be true or false.*
    + **extensive_case**: by default, bopscrk only applies the more common case transforms: all chars to lower, all chars to upper, each char to upper, all pairs to upper, all odds to upper, all consonants to upper and all vowels to upper. You can enable this option to obtain ALL possible case transforms, which can result in much larger wordlists, but might be useful in some scenarios. *Can be true or false.*
    + **remove_parenthesis**: remove all parenthesis in lyrics found before any transform
    + **take_initials**: produce words based on initial of each word in lyric phrases found (if enabled with remove_parenthesis disabled, it can produce useless words)
    + **artist_split_by_word**: split artist names and add each word as a new one
    + **lyric_split_by_word**: same with lyrics found
    + **artist_space_replacement**: replace spaces in artist names with chars/strings defined in charset
    + **lyric_space_replacement**: same with lyrics found
    + **space_replacement_chars**: characters to insert instead of spaces inside an artist name or a lyric phrase.  *Can be a single char or a string of chars, e.g.: `!?-/&(`*
    + **space_replacement_strings**: strings to insert instead of spaces inside an artist name or a lyric phrase.  *Can be a single string or a list of strings space-separated, e.g.: `123` `34!@`*

  + **Parameters configuration examples**
    + Combine all the words using dots as separator, and same using commas
      `separators_chars=.,`
    + Convert all "a/A" occurrences into "4" and all "e/E" occurrences into "3"
      `leet_charset=a:4 e:3`

  <p align="right">(<a href="#top">back to top</a>)</p>


  <p align="center"><img src="https://github.com/R3nt0n/bopscrk/blob/master/img/lyricpass_demo.png" /></p>

  This feature is based in a modified version of a [tool](https://github.com/initstring/lyricpass) developed originally by [initstring](https://github.com/initstring/). The changes are made to integrate input and output's tool with bopscrk.

  It will retrieve all lyrics from all songs which belongs to artists that you provide. **By default it will store each artist, each phrase found with space substitution, each phrase found reduced to its initials** (which will be transformed later if you have activated leet and case transforms).

  <p align="right">(<a href="#top">back to top</a>)</p>

  <!-- ROADMAP -->


  - [ ] Improve **memory management**
      - [ ] Write wordlists into filesystem during execution and use it as cache (<a href="https://github.com/r3nt0n/bopscrk/issues">#12</a>)
  - [ ] Improve **performance**
      - [x] Improve parallelism logic
  - [ ] Extra features
      - [x] Implement **progress bar** to keep user informed of the execution state
      - [ ] Implement **session file** to keep track of the execution point and **be able to stop and resume sessions** (<a href="https://github.com/r3nt0n/bopscrk/issues">#12</a>)
      - [ ] Create **config options** for customized **case transforms** (e.g.: disable pair/odd transforms)
      - [ ] Implement "pipable" output to allow integration with other tools (`-q` flag will just output final wordlist to sdout)

  See the [open issues](https://github.com/r3nt0n/bopscrk/issues) for a full list of proposed features (and known issues).

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- CONTRIBUTING -->


  Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
  Don't forget to give the project a star! Thanks again!

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request



  * [noraj](https://github.com/noraj) contributed opening several issues and pull requests that have allow to fix some important bugs. He also managed by his own the tool's addition in BlackArch and RawSec repositories, which has increase its popularity and use
  * [nylocx](https://github.com/nylocx) and [agoertz-fls](https://github.com/agoertz-fls) contributed adding Python3 support
  * [glozanoa](https://github.com/glozanoa) and [fabaff](https://github.com/fabaff) contributed adding bopscrk command (improvements on setup.py)

  Thank you all!

  <p align="right">(<a href="#top">back to top</a>)</p>




  [//]: # (+ `last development version &#40;available on Github&#41;`)
  + `2.4.7 version notes (02/09/2024)`
    + Improving **case transform logic** (now it respects the case from the original word)
    + Including **new basic case transform operations**
    + Implementing **extensive case transform mode**
    + Fixing typos

  + `2.4.6 version notes (30/08/2024)`
    + **Increasing parallelism performance** (real multiprocessing implementation)
    + Better handling of config parser errors
    + Fixing typos

  + `2.4.5 version notes (02/08/2022)`
    + **progress bar** implemented and working
    + `version` argument included
    + Docs improved

  + `2.4.4 version notes (31/07/2022)`
    + **Relative imports bug fixed**
    + Starting to refactor general structure to allow **progressbar feature inclusion**

  + `2.4.3 version notes (28/07/2022)`
    + Fixing project structure to allow properly install via pip:
      + Add MANIFEST to exclude compiled and tests files when building dist
      + Improving structure to properly copy all structure into python packages dir inside a parent dir
      + Fixing relative path to config file
    + Catch exception when a wrong config file was provided (notice and exit)

  + `2.4 version notes (26/07/2022)`
    + Make the installation process easier enabling `pip install` method
    + Starting to implement better memory management (cached wordlists writing and reading i/o files), not working yet
    + Updating and fixing minor bugs related to dependencies
    + **REMOVED FEATURE**: 'exclude from other wordlists', doesn't seem useful, there are other tools to do this specific work

  + `2.3.1 version notes`
    + Fixing namespace bug (related to aux.py module, renamed to auxiliars.py) when running on windows systems
    + **unittest** (and simple unitary tests for transforms, excluders and combinators functions) **implemented**.

  + `2.3 version notes (15/10/2020)`
    + **Customizable** configuration for **artists and lyrics transforms** using the cfg file
    + Requirements at **setup.py updated**
    + **Multithreads logic improved**
    + **Leet and case order reversed** to improve operations efficiency
    + **BUG FIXED** in lyrics space replacement
    + **BUG FIXED** when remove duplicates (*Type Error: unhashable type: 'list'*)
    + **Memory management and efficiency improved**
    + **SPLIT INTO MODULES** to improve project structure
    + **BUG FIXED** in wordlists-exclusion feature

  + `2.2 version notes (11/10/2020`
    + **Configuration file** implemented
    + **NEW FEATURE**: Allow to create **custom charsets** and **transforms patterns** trough the **config file**
    + **NEW FEATURE**: **Recursive leet transforms** implemented (*disabled by default*, can be enabled in cfg file)

  + `2.2~beta version notes (10/10/2020)`
    + The **lyricpass** integration have been **updated to run with last version released by initstring**
    + `--lyrics-all` option removed (feature integrated in other options)

  + `2.1 version notes (11/07/2020)`
    + Fixing **min and max length bug**

  + `2.0/1.5 version notes (17/06/2020)`
    + **PYTHON 3 NOW IS SUPPORTED**: master branch moves to Python 3. Secondary branch keeps Python 2.7 legacy support

  + `0-1.2(beta) version notes`
    + **EXCLUDE WORDLISTS**: speed improvement using multithreaded exclusions
    + **NEW FEATURE**: lyrics searching related to artists increase the wordlist chances

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- LICENSE -->


  Distributed under the GNU General Public License v3.0. See `LICENSE` for more information.

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- CONTACT -->


  r3nt0n: [Github](https://github.com/r3nt0n) - [email](r3nt0n@protonmail.com)
  bopscrk: [Github](https://github.com/r3nt0n/bopscrk) - [Pypi](https://pypi.org/project/bopscrk)

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- ACKNOWLEDGMENTS -->


  * lyricpass module is based on a [project](https://github.com/initstring/lyricpass) created by [initstring](https://github.com/initstring).
  * [Pixel Gothic font](https://dafonttop.com/pixel-gothic-font.font) by [Kajetan Andrzejak](https://dafonttop.com/tags.php?key=Kajetan%20Andrzejak).
  * [Best-README-Template](https://github.com/othneildrew/Best-README-Template) by [othneildrew](https://github.com/othneildrew/).

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- LEGAL DISCLAIMER -->

  This tool is created for the sole purpose of security awareness and education, it should not be used against systems that you do not have permission to test/attack. The author is not responsible for misuse or for any damage that you may cause. You agree that you use this software at your own risk.

  <p align="right">(<a href="#top">back to top</a>)</p>


pkgId: 59460d93a9612fd954c80c0686b52fb8aed5cb556a61f55a86ad962320895c8b
name: python-borax
arch: src
version: 4.1.1
epoch: 0
release: 1
summary: A tool collections.(Chinese-Lunar-Calendars/Python-Patterns)
url: https://github.com/kinegratii/borax
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borax-4.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/borax.svg)](https://pypi.org/project/borax)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/borax.svg)](https://pypi.org/project/borax)
  ![Python package](https://github.com/kinegratii/borax/workflows/Python%20package/badge.svg)
  ![Codecov](https://codecov.io/github/kinegratii/borax/coverage.svg)
  ![GitHub license](https://img.shields.io/github/license/kinegratii/borax)
  [![borax](https://snyk.io/advisor/python/borax/badge.svg)](https://snyk.io/advisor/python/borax)




  > github  https://github.com/kinegratii/borax
  >
  > gitee  https://gitee.com/kinegratii/borax



  Borax 是一个Python3工具集合库。包括了以下几个话题：

  | 话题（Topics）      | 内容                                                  |
  | ------------------- | ----------------------------------------------------- |
  | Borax.LunarDate     | 1900-2100年的中国农历日期库                           |
  | Borax.Festivals     | 实现常见节日（公历、农历、星期、节气）的工具库                           |
  | Borax.Choices       | 声明式的选项类。适用于Django.models.choices 定义。    |
  | Borax.Datasets      | 记录型数据操作库，包括连结（Join）、列选择（fetch）等 |
  | Borax.DataStuctures | 树形结构，json数据                                    |
  | Borax.Numbers       | 数字库。包括中文数字、百分数等。                      |
  | Borax.Patterns      | 设计模式。包括单例模式、代理对象、延迟对象。          |



  Borax 的 python 版本要求如下

  | borax 版本 | python版本 | 维护状态 |
  | ------ | ------ | ------ |
  | 4.1.x | 3.9+ | 维护开发 |
  | 4.0.0 | 3.7+ | 维护至2024年12月31日 |
  | 3.x | 3.5+ | 不再维护 |

  可以通过 *pip* 安装 ：

  ```shell
  $ pip install borax
  ```



  Borax的版本符合 [语义化版本](https://semver.org/lang/zh-CN/) ，格式为 `<主版本号>.<副版本号>.<修正版本号>`， 推荐使用下面方式定义Borax的依赖版本号。

  ```text
  borax~=4.1
  ```





  一个支持1900-2100年的农历日期工具库。

  > 本模块的数据和算法参考自项目 [jjonline/calendar.js](https://github.com/jjonline/calendar.js)  ，部分算法和数据有所修改。

  创建日期，日期推算

  ```python
  from datetime import timedelta
  from borax.calendars import LunarDate


  print(LunarDate.today()) # LunarDate(2018, 7, 1, 0)


  ld = LunarDate.from_solar_date(2018, 8, 11)
  print(ld) # LunarDate(2018, 7, 1, 0)


  print(ld.after(10)) # LunarDate(2018, 7, 11, 0)


  print(ld + timedelta(days=10)) # LunarDate(2018, 7, 11, 0)
  ```

  格式化字符串

  ```python
  today = LunarDate.today()
  print(today.strftime('%Y年%L%M月%D')) # '二〇一八年六月廿六'
  print(today.strftime('今天的干支表示法为：%G')) # '今天的干支表示法为：戊戌年庚申月辛未日'
  ```



  创建春节（每年正月初一）对应的节日对象

  ```python
  from borax.calendars.festivals2 import LunarFestival

  festival = LunarFestival(month=1, day=1)
  print(festival.description) # '农历每年正月初一'


  print(festival.countdown()) # (273, <WrappedDate:2022-02-01(二〇二二年正月初一)>)


  print([str(wd) for wd in festival.list_days(start_date=date.today(), count=5)])
  ```



  | 节日                          | 表示法                                                | 规范化描述                |
  | ----------------------------- | ----------------------------------------------------- | ------------------------- |
  | 元旦                          | SolarFestival(month=1, day=1)                         | 农历每年正月初一          |
  | 中秋节                        | LunarFestival(month=8, day=15)                        | 农历每年八月十五          |
  | 母亲节（每年5月第二个周日）   | WeekFestival(month=5, index=2, week=calendar.SUNDAY)  | 公历每年5月第2个星期日    |
  | 除夕             | LunarFestival(day=-1)                                 | 农历每年最后一天          |
  | 程序员节                      | SolarFestival(freq=FreqConst.YEARLY，day=256)         | 公历每年第256天           |
  | 清明节                        | TemFestival(name="清明")                              | 公历每年清明              |
  | 每月5日                       | SolarFestival(freq=FreqConst.MONTHLY， day=5)         | 公历每月5日               |
  | 国际麻风节       | WeekFestival(month=1, index=-1, week=calendar.SUNDAY) | 公历1月倒数第1个星期日    |
  | 每月最后一个周日 | WeekFestival(month=0, index=-1, week=calendar.SUNDAY) | 公历每月倒数第1个星期日   |
  | 初伏 | TemFestival('夏至', nth=3, day_gz='庚') | 公历每年夏至起第三个庚日   |



  基本使用示例

  ```python
  from datetime import date
  from borax.calendars.festivals2 import FestivalLibrary, WrappedDate

  library = FestivalLibrary.load_builtin()


  names = library.get_festival_names(date(2020, 10, 1))
  print(names) # ['国庆节', '中秋节']


  festival = library.get_festival('七夕')
  print(festival.description) # '农历每年七月初七'
  print(WrappedDate(festival.at(year=2021))) # '2021-08-14(二〇二一年七月初七)'
  ```

  计算节日及其距离今天（2021年5月4日）的天数

  ```python

  from borax.calendars.festivals2 import FestivalLibrary

  library = FestivalLibrary.load_builtin()
  for ndays, wd, festival in library.list_days_in_countdown(countdown=365):
      print(f'{ndays:>3d} {wd} {festival.name}')
  ```

  输出结果

  ```
    0 2022-05-04(四月初四) 青年节
    4 2022-05-08(四月初八) 母亲节
    8 2022-05-12(四月十二) 护士节
  ...
  332 2023-04-01(闰二月十一) 愚人节
  336 2023-04-05(闰二月十五) 清明
  362 2023-05-01(三月十二) 劳动节

  ```





  不同形式的中文数字

  ```python
  from borax.numbers import ChineseNumbers


  print(ChineseNumbers.measure_number(204)) # '二百零四'

  print(ChineseNumbers.order_number(204)) # '二百〇四'

  print(ChineseNumbers.measure_number(204, upper=True)) # '贰佰零肆'

  print(ChineseNumbers.order_number(204, upper=True)) # '贰佰〇肆'
  ```

  财务金额

  ```python
  import decimal

  from borax.numbers import FinanceNumbers

  decimal.getcontext().prec = 2

  print(FinanceNumbers.to_capital_str(100000000)) # '壹亿元整'
  print(FinanceNumbers.to_capital_str(4578442.23)) # '肆佰伍拾柒万捌仟肆佰肆拾贰元贰角叁分'
  print(FinanceNumbers.to_capital_str(107000.53)) # '壹拾万柒仟元伍角叁分'
  print(FinanceNumbers.to_capital_str(decimal.Decimal(4.50))) # '肆元伍角零分'
  ```

  更多模块功能参见文档。



  文档由 [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) 构建 ~~，另外备用文档使用 [docsify](https://docsify.js.org/) 构建~~ 。

  > 2024年1月起，仅保留 Read the Docs 文档源。

  | 源 | 网址 |
  | ---- | ---- |
  | read-the-docs | [https://borax.readthedocs.io/zh_CN/latest/](https://borax.readthedocs.io/zh_CN/latest/) |
  | github（已废弃） | [https://kinegratii.github.io/borax](https://kinegratii.github.io/borax) |
  | gitee（已废弃） | [https://kinegratii.gitee.io/borax](https://kinegratii.gitee.io/borax) |



  - [x] [Typing Hints](https://www.python.org/dev/peps/pep-0484/)
  - [x] [Flake8 Code Style](http://flake8.pycqa.org/en/latest/)
  - [x] [nose2](https://pypi.org/project/nose2/) | [pytest](https://docs.pytest.org/en/latest/)
  - [x] [Github Action](https://github.com/kinegratii/borax/actions)
  - [x] [Code Coverage](https://codecov.io/)
  - [x] [pyproject.toml build tools](https://packaging.python.org/)



  从4.1.0 开始，borax 使用 *pyproject.toml* 作为项目构建的配置文件，使用以下命令构建 wheel 发行包。

  ```shell
  python -m build -w
  ```



  The MIT License (MIT)


pkgId: 723b3357af599526998522f3fa29dba4ce84791a5869cf99c421630d5f1984ae
name: python-borb
arch: src
version: 2.1.25
epoch: 0
release: 1
summary: borb is a library for reading, creating and manipulating PDF files in python.
url: https://github.com/jorisschellekens/borb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borb-2.1.25-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Corpus Coverage : 100.0%](https://img.shields.io/badge/corpus%20coverage-100.0%25-green)]()
  [![Text Extraction : 93.1%](https://img.shields.io/badge/text%20extraction-93.1%25-green)]()
  [![Public Method Documentation : 100%](https://img.shields.io/badge/public%20method%20documentation-100%25-green)]()
  [![Number of Tests : 760](https://img.shields.io/badge/number%20of%20tests-760-green)]()
  [![Python : 3.8 | 3.9 | 3.10 ](https://img.shields.io/badge/python-3.8%20&#124;%203.9%20&#124;%203.10-green)]()
  [![Type Checking : 98%](https://img.shields.io/badge/type%20checking-98%25-green)]()


  [![Downloads](https://pepy.tech/badge/borb)](https://pepy.tech/project/borb)
  [![Downloads](https://pepy.tech/badge/borb/month)](https://pepy.tech/project/borb)

  `borb` is a library for creating and manipulating PDF files in python.



  `borb` is a pure python library to read, write and manipulate PDF documents.
  It represents a PDF document as a JSON-like datastructure of nested lists, dictionaries and primitives (numbers, string, booleans, etc)

  This is currently a one-man project, so the focus will always be to support those use-cases that are more common in favor of those that are rare.



  The examples can be found in a separate repository.
  This ensures the `borb` repository stays relatively small, whilst still providing a thorough knowledgebase of code-samples, screenshots and explanatory text.

  [Check out the examples repository here!](https://github.com/jorisschellekens/borb-examples)

  They include;

  - Reading a PDF and extracting meta-information
  - Changing meta-information
  - Extracting text from a PDF
  - Extracting images from a PDF
  - Changing images in a PDF
  - Adding annotations (notes, links, etc) to a PDF
  - Adding text to a PDF
  - Adding tables to a PDF
  - Adding lists to a PDF
  - Using a PageLayout manager

   and much more



  `borb` can be installed using `pip`

      pip install borb

  If you have installed `borb` before, and you want to ensure `pip` downloads the latest version (rather than using its internal cache) you can use the following commands:

      pip uninstall borb
      pip install --no-cache borb



  To give you an immediate idea of the way `borb` works,
  this is the classic `Hello World` example, in `borb`:

  ```python
  from pathlib import Path

  from borb.pdf import Document
  from borb.pdf import Page
  from borb.pdf import SingleColumnLayout
  from borb.pdf import Paragraph
  from borb.pdf import PDF


  pdf = Document()


  page = Page()
  pdf.add_page(page)


  layout = SingleColumnLayout(page)


  layout.add(Paragraph("Hello World!"))


  with open(Path("output.pdf"), "wb") as pdf_file_handle:
      PDF.dumps(pdf_file_handle, pdf)
  ```



  `borb` is dual licensed as AGPL/Commercial software.

  AGPL is a free / open source software license.
  This doesn't mean the software is [gratis](https://en.wikipedia.org/wiki/Gratis_versus_libre)!

  Buying a license is mandatory as soon as you develop commercial activities distributing the borb software inside your product or deploying it on a network without disclosing the source code of your own applications under the AGPL license.
  These activities include:

  - Offering paid services to customers as an ASP
  - Serving PDFs on the fly in the cloud or in a web application
  - Shipping `borb` with a closed source product

  [Contact sales](https://borbpdf.com/) for more information.



  I would like to thank the following people, for their contributions / advice with regards to developing `borb`:
  - Aleksander Banasik
  - Benoît Lagae
  - Michael Klink


pkgId: 005d5f1e3c023cf3e4a16190e6c99765a0fda03817aec67e0341c5178540b40f
name: python-borg-queen
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Wrapper for Borg Backup.
url: https://bitbucket.org/indev/queen/
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borg-queen-1.0.1-1.src.rpm
checksum_type: sha256
description:
  A wrapper around [Borg backup](https://www.borgbackup.org/).

  Like other borg wrappers, queen defines a site config file format that specifies
  what contents should go in a borg archive. It also defines a standard location
  in /etc/ where it will look for these site config files automatically. Unlike other
  wrappers, it can run some predefined actions (called plugins), that generate
  files to be included in the backup.

  Currently, there are three plugins:

  -	'postgres' that creates binary dumps using `pg_dump`
  -	'mysql' that creates sql dumps using `mysqldump`
  -	'docker_volume' that creates tarballs out of docker volumes

  More plugins may be defined in the future.



  Install using pip.

  You must also have `borg` installed and available on the PATH.

  If you use the `postgres` plugin, you also need `pg_dump` installed.

  If you use the `mysql` plugin, you also need `mysqldump` installed.

  If you use the `docker_volume` plugin, you also need `docker` installed.



      usage: queen [-h] [-s SITE_CONFIG]

      Take backups using Borg

      optional arguments:
        -h, --help            show this help message and exit
        -s SITE_CONFIG, --site-config SITE_CONFIG
                              Backup using the supplied config file instead of those
                              in /etc/queen/sites.d/


  Unless supplied with `-s`, queen will process all site configs in
  `/etc/queen/sites.d/`.



  Queen reads its configuration from `/etc/queen/queen.toml`

  ```toml
  repo_prefix = 'some@repo:prefix'
  sentry_dsn = 'some sentry dsn'

  [logging]
  directory = '/some/directory/'

  [borg_env]
  BORG_RELOCATED_REPO_ACCESS_IS_OK = 'yes'

  [plugins.postgres]
  host = 'localhost'
  ```

  `repo_prefix`, `sentry_dsn` and `logging.directory` are required.

  The repo location will be a subdirectory inside `repo_prefix` named after your
  site config's `project_name`. You can pass a [remote repository URL][1] to
  create your repo in a remote host, such as `user@host:/path`. The path
  specified in `repo_prefix` must already exist.


  [1]: https://borgbackup.readthedocs.io/en/stable/usage/general.html#repository-urls

  The `borg_env` table may contain environment variables. These will be used for
  the call to `borg create`.

  The `plugins` table may contain a table of tables. Keys under `plugins` must
  correspond to plugin names. Key inside each plugin will be merged with each
  site's plugin configs, with the site's values taking precedence.


  Site configs should be in toml and placed in `/etc/queen/sites.d/`

  ```toml
  project_name = 'myproject'
  passphrase = 'some secret'
  paths = [
  	'/srv/python/myproject',
  	'/etc/myproject'
  ]

  [[plugins.postgres]]
  database = 'myproject'

  [[plugins.mysql]]
  database = 'myproject'
  user = 'dbuser'
  password = 'dbpassword'
  ```

  Some notes:

  -	`project_name` and `passphrase` are required
  -	`paths` should be absolute
  -	If any of the paths does not exist, queen will emit a WARNING and create a
  	borg archive with the rest of the configuration (existing paths and plugins)



  Plugins may be configured both globally and per site. When both configurations
  are present, they are merged with the site's configuration taking precedence.

  For example, if you want to use a specific username & password for backing up
  postgres databases, you may specify them in the global configuration's `plugins.postgres`
  table. You can then specify the rest of the configuration (eg. `database`) in each
  site without repeating the username & password. If a single still site needs to override
  the username & password, you can specify it on just that site and they will override the
  ones in the global configuration.



  `plugins.postgres` should be a list of tables, each one describing a database.
  Each table may contain the following keys:

  -	`database`
  -	`user`
  -	`password`
  -	`host`
  -	`port`
  -	`pg_dump`

  Only `database` is required, all other keys are optional.

  `user`, `password`, `host` and `port` will be used to connect to postgres.

  `pg_dump` must be a list of strings and will be used as the binary to use for taking
  backups. It is useful for specifying wrapper scripts for pg_dump, for example:

  -	`['sudo', '-iu', 'postgres', 'pg_dump']` for changing the unix user that will invoke pg_dump.
  -	`['docker', 'exec', 'container_name', 'pg_dump']` to take a backup from a running postgres
  	container.
  -	Your own custom shell scripts, wrapping pg_dump

  It must be compatible with the actual pg_dump binary and it defaults to `['pg_dump']`.


  For backwards compatibility, `plugins.postgres` may be a list of strings, which
  are interpreted as database names.



  Full config:

  ```toml

  [[plugins.postgres]]
  database = 'database_1'
  user = 'user'
  password = 'password'
  host = 'host'
  port = 1234
  pg_dump = ['sudo', '-iu', 'postgres', 'pg_dump']

  [[plugins.postgres]]
  database = 'database_2'
  user = 'user'
  password = 'password'
  host = 'host'
  port = 1234
  ```

  Legacy config:

  ```toml
  [plugins]
  postgres = [
  	'database_1',
  	'database_2'
  ]
  ```



  `plugins.mysql` should be a list of tables, each one describing a database.
  Each table may contain the following keys:

  -	`database`
  -	`user`
  -	`password`
  -	`host`
  -	`port`

  Only `database` is required, all other keys are optional.



  ```toml
  [[plugins.mysql]]
  database = 'myproject'
  host = '127.0.0.1'
  port = 1234
  user = 'dbuser'
  password = 'dbpassword'
  ```



  `plugins.docker_volume` should be a list of tables, each one describing a
  docker volume. Each table may contain the following keys:

  - `name`: the name of the docker volume. Required.
  -	`image`: the image that will be used for making the tarball. Defaults to `alpine`


  ```toml
  [[plugins.docker_volume]]
  name = 'my_volume'

  [[plugins.docker_volume]]
  name = 'my_other_volume'
  image = 'debian:bullseye-slim'
  ```




  Queen is going to use your project as the repo name and create it if it does
  not exist. Each Archive will be named as the ISO-8601 timestamp of the time the
  backup was taken in UTC (unlike borg's `{utcnow}` it includes a timezone).

  Inside each archive, your `paths` are included as is. Plugins place their
  content inside `_queen/{plugin_name}`.

  Using the config above as an example your archive would contain:

  	srv/
  		python/
  			myproject/
  				...
  	etc/
  		myproject/
  			...
  	_queen/
  		postgres/
  			myproject.pgdump
  		mysql/
  			myproject.dump.sql


pkgId: 812780d293db8d0f57b7fb03e6b44ae289898f5e12aac65125616a6cc6a19094
name: python-borgctl
arch: src
version: 0.4.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/borgctl/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borgctl-0.4.11-1.src.rpm
checksum_type: sha256
description:
  repository: ""
  ssh_key: ""
  prefix: ""
  passphrase: ""
  mount_point: "/mnt"
  borg_create_backup_dirs:
    - "/"
  borg_create_excludes:
    - ".cache"
  borg_create_arguments:
    - "--one-file-system"
    - "--compression=lz4"
  borg_prune_arguments:
    - "--keep-last 10"
    - "--dry-run"
  cron_commands:
  - "create"
  - "prune"
  - "compact"
  state_commands:
  - "create"
  - "prune"

  envs:
    "BORG_RELOCATED_REPO_ACCESS_IS_OK": "yes"
  borg_binary: "/usr/bin/borg"
  ```

  borgctl needs a configuration file. If you run it without specifying one, a default.yml in the default config location is expected to exist. If you run it and there is no default.yml, you can use `--generate-default-config` to create one:
  ```bash
  root@linbox:~ borgctl list
  2023-12-26 10:58:31,564  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 10:58:31,564 ERROR Could not load config file /etc/borgctl/default.yml
  Please use --generate-default-config to create a default config
  root@linbox:~ borgctl --generate-default-config
  2023-12-26 10:59:28,107  INFO Please make a backup of the passphrase!
  2023-12-26 10:59:28,112  INFO Successfully wrote config file to /etc/borgctl/default.yml
  ```
  `/etc/borgctl/default.yml` is based on the [default config file](https://github.com/kmille/borgctl/blob/main/borgctl/default.yml.template) and gets new diceware-like password for the borg passphrase . Also the hostname is set as borg prefix. It's crucial to make a backup of the passphrase!

  ```bash
  root@linbox:~ borgctl --generate-ssh-key
  2023-12-26 11:06:12,784  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:06:12,785  INFO Running ['ssh-keygen', '-t', 'ed25519', '-N', '', '-q', '-f', '/root/.ssh/borg_default', '-C', 'kmille_borg_default@linbox']
  2023-12-26 11:06:12,794  INFO Successfully created ssh key /root/.ssh/borg_default
  2023-12-26 11:06:12,805  INFO Updated ssh_key in /etc/borgctl/default.yml
  root@linbox:~ cat /root/.ssh/borg_default.pub
  ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINpVZZjIAzeyGq0oLKVeLzEECoe7RXg6YpAcPIsakboF kmille_borg_default@linbox
  ```
  If you specify a ssh key in the config file, it will be used as output file (if it does not exist). If not, the default name for the ssh key is `$currentUsername_borg_$configPrefix`.

  ```bash
  root@linbox:~ borgctl --generate-authorized_keys
  2023-12-26 11:07:47,549  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:07:47,551  INFO Using ssh key /root/.ssh/borg_default.pub from config file
  2023-12-26 11:07:47,551  INFO Add this line to authorized_keys:
  ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINpVZZjIAzeyGq0oLKVeLzEECoe7RXg6YpAcPIsakboF kmille_borg_default@linbox
  2023-12-26 11:07:47,551  INFO Use this line for restricted access:
  command="borg serve --restrict-to-path /opt/test-backup",restrict ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINpVZZjIAzeyGq0oLKVeLzEECoe7RXg6YpAcPIsakboF kmille_borg_default@linbox
  2023-12-26 11:07:47,553  INFO Or this all-in-one command:
  echo -e 'command="borg serve --restrict-to-path /opt/test-backup",restrict ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINpVZZjIAzeyGq0oLKVeLzEECoe7RXg6YpAcPIsakboF kmille_borg_default@linbox\n' | ssh backup-host1 'cat >> /home/backuper/.ssh/authorized_keys'
  ```

  ```bash
  root@linbox:~ borgctl --list
  backend1-append.yml
  backend2-append.yml
  backend1-full.yml
  backend2-full.yml
  root@linbox:~ borgctl --list full
  backend1-full.yml
  backend2-full.yml
  ```

  Please update the config file (what to backup (`borg_create_backup_dirs` and `borg_create_excludes` and where to backup (`repository`)). Then you can create your first backup:
  ```bash
  root@linbox:~ borgctl create
  2023-12-26 11:11:35,197  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:11:35,199  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCATED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose create --progress --stats --one-file-system --compression=lz4 --exclude=.cache ::linbox_2023-12-26_11:11:35 /usr/bin
  2023-12-26 11:11:35,718  INFO Creating archive at "/root/borg-repo::linbox_2023-12-26_11:11:35"
  2023-12-26 11:12:07,934  INFO ------------------------------------------------------------------------------
  2023-12-26 11:12:07,935  INFO Repository: /root/borg-repo
  2023-12-26 11:12:07,936  INFO Archive name: linbox_2023-12-26_11:11:35
  2023-12-26 11:12:07,937  INFO Archive fingerprint: 079e9c226455ff1b816be986bf49029c3cdf28ec04e9f6bf2d387ea9a4f24d87
  2023-12-26 11:12:07,937  INFO Time (start): Tue, 2023-12-26 11:11:35
  2023-12-26 11:12:07,938  INFO Time (end):   Tue, 2023-12-26 11:12:06
  2023-12-26 11:12:07,938  INFO Duration: 31.04 seconds
  2023-12-26 11:12:07,939  INFO Number of files: 3869
  2023-12-26 11:12:07,940  INFO Utilization of max. archive size: 0%
  2023-12-26 11:12:07,940  INFO ------------------------------------------------------------------------------
  2023-12-26 11:12:07,941  INFO                        Original size      Compressed size    Deduplicated size
  2023-12-26 11:12:07,942  INFO This archive:                1.55 GB            777.29 MB            777.13 MB
  2023-12-26 11:12:07,942  INFO All archives:                1.55 GB            777.29 MB            777.43 MB
  2023-12-26 11:12:07,943  INFO
  2023-12-26 11:12:07,943  INFO                        Unique chunks         Total chunks
  2023-12-26 11:12:07,944  INFO Chunk index:                    4310                 4322
  2023-12-26 11:12:07,945  INFO ------------------------------------------------------------------------------
  2023-12-26 11:12:08,101  INFO Updated state file /var/log/borgctl/borg_state_default_create.txt
  root@linbox:~
  root@linbox:~ cat /var/log/borgctl/borg_state_default_create.txt
  2023-12-26_11:12:08#
  root@linbox:~
  root@linbox:~ ls /var/log/borgctl/borg.log
  -rw-r--r-- 1 root root 11K Dec 26 11:12 /var/log/borgctl/borg.log
  ```
  The executed borg command is also printed to stderr. You can adjust the parameters borgctl uses. For example you can add `--json /usr/local/bin/`, which will be added to borg:
  ```bash
  root@linbox:~ borgctl create --json /usr/local/bin
  2023-12-26 11:15:42,954  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:15:42,956  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCAT
  ED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose create --progress --stats --one-file-system --compression=lz4 --exclude=.cache --json ::linbox_2023-12-26_11:15:42 /usr/bin --json /usr/local/bin
  2023-12-26 11:15:43,518  INFO Creating archive at "/root/borg-repo::linbox_2023-12-26_11:15:42"
  {
      "archive": {
          "command_line": [
              "/usr/bin/borg",
  ```

  For every borg command, you can add command line parameter/arguments in the config file by specifying `borg_$borgcommand_arguments`. They are used automatically. For example, here are default arguments for the create command:
  ```yaml
  borg_create_arguments:
  - "--one-file-system"
  - "--compression=lz4"
  ```
  For convenient mounting, I like to use:
  ```yaml
  borg_mount_arguments:
  - "--strip-components=2"
  - "--foreground"
  - "--last 1"
  ```

  If you want to specify an archive, you have to prepend ::
  ```bash
  root@linbox:~ borgctl list
  2023-12-26 11:18:38,323  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:18:38,325  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCATED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose list
  linbox_2023-12-26_11:11:35           Tue, 2023-12-26 11:11:35 [079e9c226455ff1b816be986bf49029c3cdf28ec04e9f6bf2d387ea9a4f24d87]
  linbox_2023-12-26_11:15:42           Tue, 2023-12-26 11:15:43 [4599ac310b99703407600bc8bfa58ddb80da7be3d613b49fdf75691b99d293e0]
  root@linbox:~
  root@linbox:~ borgctl list linbox_2023-12-26_11:11:35
  2023-12-26 11:19:06,975  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:19:06,977  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCATED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose list linbox_2023-12-26_11:11:35
  Remote: ssh: Could not resolve hostname linbox_2023-12-26_11: Name or service not known
  2023-12-26 11:19:07,436 ERROR Connection closed by remote host. Is borg working on the server?
  2023-12-26 11:19:07,518 ERROR borg failed with exit code: 2
  root@linbox:~
  root@linbox:~ borgctl list ::linbox_2023-12-26_11:11:35
  2023-12-26 11:18:33,787  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:18:33,789  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCAT
  ED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose list ::linbox_2023-12-26_11:11:35
  drwxr-xr-x root   root          0 Tue, 2023-12-26 10:56:58 usr/bin
  -rwxr-xr-x root   root      21905 Fri, 2023-12-22 20:59:55 usr/bin/tzselect
  -rwxr-xr-x root   root      51216 Fri, 2023-12-22 20:59:55 usr/bin/zdump
  -rwxr-xr-x root   root      59448 Fri, 2023-12-22 20:59:55 usr/bin/zic
  -rwxr-xr-x root   root      27176 Sat, 2023-03-18 17:07:07 usr/bin/gdbm_dump
  ```

  `--cron` is nice if you want to have a cronjob that creates, prunes and compacts backups. In the config file, you can specify which borg commands should be run if `--cron` is supplied:
  ```yaml
  cron_commands:
  - "create"
  - "prune"
  - "compact"
  ```
  Example outupt:
  ```bash
  root@linbox:~ borgctl --cron
  2023-12-26 11:22:06,988  INFO Using config file /etc/borgctl/default.yml
  2023-12-26 11:22:06,990  INFO Running 'borg create' in --cron mode
  2023-12-26 11:22:06,990  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCATED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose create --progress --stats --one-file-system --compression=lz4 --exclude=.cache ::linbox_2023-12-26_11:22:06 /usr/bin
  2023-12-26 11:22:07,532  INFO Creating archive at "/root/borg-repo::linbox_2023-12-26_11:22:06"
  2023-12-26 11:22:08,338  INFO Updated state file /var/log/borgctl/borg_state_default_create.txt
  2023-12-26 11:22:08,338  INFO Running 'borg prune' in --cron mode
  2023-12-26 11:22:08,338  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCATED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose prune --list --keep-last 10
  2023-12-26 11:22:08,898  INFO Keeping archive (rule: secondly #1):     linbox_2023-12-26_11:22:06           Tue, 2023-12-26 11:22:07 [9be95c7822b2e195fbcdfa63787d20ceb13ba04a7d560d627f2f92941e1dc23e]
  2023-12-26 11:22:08,898  INFO Keeping archive (rule: secondly #2):     linbox_2023-12-26_11:21:35           Tue, 2023-12-26
  2023-12-26 11:22:08,969  INFO Updated state file /var/log/borgctl/borg_state_default_prune.txt
  2023-12-26 11:22:08,970  INFO Running 'borg compact' in --cron mode
  2023-12-26 11:22:08,970  INFO Executing: BORG_REPO="/root/borg-repo" BORG_LOGGING_CONF="/etc/borgctl/logging.conf" BORG_RSH="ssh -i /root/.ssh/borg_default" BORG_RELOCATED_REPO_ACCESS_IS_OK="yes" /usr/bin/borg --verbose compact
  2023-12-26 11:22:09,459  INFO compaction freed about 1.48 kB repository space.
  root@linbox:~
  ```

  borgctl also writes state files, if a borg command runs successfully. It contains the current date. You can use it for monitoring. State files are written to the log directory. The format is `borg_state__$config_file_prefix_$borg_command.txt`. In the config file you can specify a list of commands for which a state file should be created.
  ```yaml
  state_commands:
  - "create"
  - "prune"
  ```
  ```bash
  root@linbox:~ cat /var/log/borgctl/borg_state_default_create.txt
  2023-12-26_11:22:08
  ```

  If you don't want to keep your borg passphrase on your disk, you can use `ask` or `ask-always`. If you specify `ask` in your config file as passphrase, you will be ask during runtime for the passphrase. The difference between `ask` and `ask-always`: That's interesting if you run borgctl with multiple config files and different configurations. You always get asked for the password if you specify `ask-always`. If you run borgctl with three config files and every config file has `ask` specified, it only asks you for the first run. Then, it uses the previously entered password.

  In the config file, you can specify the borg binary (borg_binary) used for invocation. You can also add environment variables. If you need help for a borg command, you can just add `help` (like `borgctl list help`). You can change default arguments for specific borg commands by adding/modifying `borg_$command_arguments` in the config file (like `borg_prune_arguments`).

  If you want to authenticate with a Yubikey without touching `~/.ssh/config`, you can keep `ssh_key` empty and add
  ```yaml
  "BORG_RSH": "ssh -I /usr/lib64/pkcs11/opensc-pkcs11.so -o ForwardAgent=no -o IdentityAgent=no"
  ```
  as environment variable in the config file. But you can also stay with your `.ssh/config` if you like.

  In the config directory you will find a file called logging.conf. It is used by borgctl and borg itself for logging. The borg output (stdout and stderr) is printed to stdout, the borgctl output is printed to stderr. Everything gets logged to borg.log, which can be found in the log directory. The log file gets rotated automatically after reaching 1 megabyte. Docs can be found [here](https://docs.python.org/3/library/logging.config.html#logging.config.fileConfig) and [here](https://docs.python.org/3/library/logging.handlers.html#logging.handlers.RotatingFileHandler). [Here](https://borgbackup.readthedocs.io/en/stable/usage/general.html#logging) are the docs from borgbackup about logging.

  I use [monitoring_last_backup.py](https://github.com/kmille/borgctl/blob/main/contrib/monitoring_last_backup.py) with [py3status](https://github.com/ultrabug/py3status) on my laptop. It shows `B:3d` when my last backup was 3 days ago. The color changes from green to red after 7 days. You can run `python3 monitoring_last_backup.py` to test it.

  You need [poetry](https://python-poetry.org/docs/basic-usage/). Get get started, use `poetry install`. Then you can run `poetry run borgctl --help`. The code can be found in the borgctl directory. Deployment/monitoring stuff is in the contrib directory. Tests can be run with `poetry run pytest tests -s -v -x`.  To run the mypy checks, run `poetry run mypy`. Mypy is configured in `pyproject.toml`.


pkgId: 5c559a2e12e08c87aff94801ef04d63337c3e7fce2c1cc6cd846bc6df05b8a08
name: python-boringavatars
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A Python port of the boring-avatars JS library.
url: https://pypi.org/project/boringavatars/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boringavatars-1.0.3-1.src.rpm
checksum_type: sha256
description:
  boringavatars is a Python port of the <a href="https://www.npmjs.com/package/boring-avatars">boring-avatars</a> JS library.

  ![Build Status](https://github.com/federicobond/boringavatars/actions/workflows/python-package.yml/badge.svg?branch=main)
  [![Supported Versions](https://img.shields.io/pypi/pyversions/boringavatars.svg)](https://pypi.python.org/pypi/boringavatars)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  ```
  pip install boringavatars
  ```



  ```python
  from boringavatars import avatar


  avatar(
      "Maria Mitchell",
      variant="marble",
      colors=["92A1C6", "146A7C", "F0AB3D", "C271B4", "C20D90"],
      title=False,
      size=40,
      square=True,
  )
  ```



  MIT


pkgId: 879a2858940377969ecadecfc27bca30b5335b48300ae6cf3bec93e7df19e9f5
name: python-boris-spider
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: A high-level Web Crawling and Web Scraping framework
url: https://github.com/Boris-code/boris-spider.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boris-spider-1.1.3-1.src.rpm
checksum_type: sha256
description:
                      url  = https://www.baidu.com
                      method = GET
                      body = {'timeout': 22, 'stream': True, 'verify': False, 'headers': {'User-Agent': 'Mozilla/5.0 (Windows NT 4.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2049.0 Safari/537.36'}}
      百度一下
      Thread-2|2020-05-19 18:23:41,727|parser_control.py|run|line:415|INFO| parser 等待任务 ...
      FirstSpider|2020-05-19 18:23:44,735|single_spider.py|run|line:83|DEBUG| 无任务，爬虫结束

  框架内的utils/tools.py模块下积累了作者多年的工具类函数，种类达到100+，且之后还会不定期更新，具有搬砖价值!

  想了解更多框架使用详情，可访问官方文档：https://spider-doc.readthedocs.io
  如学习中遇到问题，可加下面的QQ群
  群号:750614606
  ![WechatIMG188](http://markdown-media.oss-cn-beijing.aliyuncs.com/2020/04/08/wechatimg188.jpeg)
  知识星球：
  ![知识星球](http://markdown-media.oss-cn-beijing.aliyuncs.com/2020/02/16/zhi-shi-xing-qiu.jpeg)
  星球会不定时分享爬虫技术干货，涉及的领域包括但不限于js逆向技巧、爬虫框架刨析、爬虫技术分享等


pkgId: 4b9ce2548cf21068c80b8589c46c51698aef0dfbca5761aa39940340f432353c
name: python-bork
arch: src
version: 9.0.0
epoch: 0
release: 1
summary: A program to help build, maintain, and release PEP 517-compliant projects.
url: https://pypi.org/project/bork/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bork-9.0.0-1.src.rpm
checksum_type: sha256
description:
  A frontend for building and releasing [PEP 517](https://www.python.org/dev/peps/pep-0517/) compliant projects, including support for generating a [ZipApp](https://docs.python.org/3/library/zipapp.html).

  Includes a basic task runner, in the form of `bork run <task name>`. Tasks
  are defined in your `pyproject.toml` file.

  Bork requires Python 3.8 or newer.

  [build-status-img]: https://api.cirrus-ci.com/github/duckinator/bork.svg
  [build-status-link]: https://cirrus-ci.com/github/duckinator/bork

  [pypi-version-img]: https://img.shields.io/pypi/v/bork
  [pypi-version-link]: https://pypi.org/project/bork



  ```
  $ pip3 install bork
  ```

  Or download [the latest zipapp
  releases](https://github.com/duckinator/bork/releases/latest/download/bork.pyz)



  Example usage information is provided below. Additional documentation can be found at [bork.readthedocs.io](https://bork.readthedocs.io/).



  To download a release from GitHub:

  ```
  $ bork download gh:duckinator/emanate # download latest .pyz for Emanate
  $ bork download gh:duckinator/emanate --directory bin/ # put files in ./bin
  $ bork download gh:ppb/pursuedpybear --files '*.tar.gz' # download latest .tar.gz file
  ```

  To download a wheel from a PyPi release:

  ```
  $ bork download pypi:emanate 6.0.0 --files '*.whl'
  ```


  To download a wheel from a release on PyPi's test instance:

  ```
  $ bork download testpypi:whaledo 1.0.1 --files '*.whl'
  ```



  Assuming a project is PEP 517 compliant, you can just do:

  ```
  $ bork clean # Remove anything in build/, dist/, *.egg-info/
  $ bork build # Build the project
  $ bork release # Release to PyPI
  ```



  If you want to build a ZipApp, add this to your pyproject.toml:

  ```
  [tool.bork.zipapp]
  enabled = true
  main = "<entrypoint>"
  ```

  Where `<entrypoint>` is of the form "module.submodule:function", and
  may be equivalent to a `console_script` entrypoint in setup.cfg.

  **NOTE**: ZipApps will only be compressed when using Python 3.7 and later. This means ZipApps created with older versions may be significantly larger.



  If you want to upload assets to GitHub Releases, you can
  add the following configuration to your pyproject.toml:

  ```
  [project]
  name = "<project name>"

  [tool.bork.release]

  pypi = true

  github = true # release to GitHub

  github_repository = "<owner>/<repo>"

  github_release_globs = ["dist/*.pyz", "dist/*.whl"]

  strip_zipapp_version = true
  ```



  Bork includes a very basic task runner, for single-line commands.

  As an example, here is what Bork uses:

  ```toml
  [tool.bork.aliases]
  lint = [
      "pylint bork tests",
      "mypy bork",
  ]

  test = "pytest --verbose"

  test-fast = "pytest --verbose -m 'not slow'"

  test-slow = "pytest --verbose -m slow"

  docs = "mkdocs build"
  ```

  Then you can run `bork aliases` to get the list of aliases:

  ```
  ~/bork$ bork aliases
  lint
  test
  test-fast
  test-slow
  ~/bork$
  ```

  And run `bork run <alias>` to run that alias:

  ```
  ~/bork$ bork run docs
  mkdocs build
  INFO     -  Cleaning site directory
  INFO     -  Building documentation to directory: /usr/home/puppy/bork/site
  INFO     -  Documentation built in 0.25 seconds
  ~/bork$
  ```



  Bug reports and pull requests are welcome on GitHub at https://github.com/duckinator/bork. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the
  [code of conduct](https://github.com/duckinator/bork/blob/master/CODE_OF_CONDUCT.md).

  The code for Bork is available under the [MIT License](http://opensource.org/licenses/MIT).


pkgId: 792e8429465264f5da2ad1b91cb038cfef61bfbc3ba4a6321d5d4155178df6c7
name: python-borneo
arch: src
version: 5.4.2
epoch: 0
release: 1
summary: Oracle NoSQL Database Python SDK
url: https://nosql-python-sdk.readthedocs.io/en/stable/index.html
rpm_license: Universal Permissive License 1.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borneo-5.4.2-1.src.rpm
checksum_type: sha256
description:
  This is the Python SDK for Oracle NoSQL Database. Python versions 3.5+ are
  supported. The SDK provides interfaces, documentation, and examples to help
  develop Python applications that connect to the Oracle NoSQL Database Cloud
  Service, Oracle NoSQL Database and to the Oracle NoSQL Cloud Simulator (which
  runs on a local machine).

  In order to run the Oracle NoSQL Cloud Simulator, a separate download is
  necessary from the Oracle NoSQL OTN download page. Throughout the documentation,
  the Oracle NoSQL Database Cloud Service and Cloud Simulator are referred to as
  the "cloud service" while the Oracle NoSQL Database is referred to as
  "on-premise." In the [API reference](https://nosql-python-sdk.readthedocs.io/en/stable/api.html) classes and interfaces are noted if they are only relevant to
  a specific environment.

  The on-premise configuration requires a running instance of the Oracle NoSQL
  database. In addition a running proxy service is required. See [Oracle NoSQL
  Database Downloads](https://www.oracle.com/database/technologies/nosql-database-server-downloads.html) for downloads, and see [Information about the proxy](https://docs.oracle.com/pls/topic/lookup?ctx=en/database/other-databases/nosql-database/22.3/admin&id=NSADM-GUID-C110AF57-8B35-4C48-A82E-2621C6A5ED72)  for
  proxy configuration information.

  This project is open source and maintained by Oracle Corp. The home page for the
  project is [here](https://nosql-python-sdk.readthedocs.io/en/stable/index.html).



  The SDK can be installed using pip. If using Python 3 the command may be pip3::

      pip install borneo

  If you are using the Oracle NoSQL Database cloud service you will also need to
  install the oci package::

      pip install oci

  See [the installation guide](https://nosql-python-sdk.readthedocs.io/en/stable/installation.html) for additional requirements and and alternative install
  methods.



  Examples can be found [on GitHub](https://github.com/oracle/nosql-python-sdk/tree/master/examples)

  Examples include simple, standalone programs. They include comments about how
  they can be configured and run in the different supported environments.



  The [documentation](https://nosql-python-sdk.readthedocs.io/en/stable) has
  information on using the SDK as well as an [API reference](https://nosql-python-sdk.readthedocs.io/en/stable/api.html) describing the classes.



  See the [Changelog](https://github.com/oracle/nosql-python-sdk/blob/master/CHANGELOG.md)



   * Open an issue in the [Issues](https://github.com/oracle/nosql-python-sdk/issues) page.
   * Email to nosql_sdk_help_grp@oracle.com.
   * [Oracle NoSQL Developer Forum](https://community.oracle.com/community/groundbreakers/database/nosql_database).

  When requesting help please be sure to include as much detail as possible,
  including version of the SDK and **simple**, standalone example code as needed.



  The following is a quick start tutorial to run a simple program in the supported
  environments. The same template source code is used for all environments. The
  first step is to cut the program below and paste it into an editor for minor
  modifications. The instructions assume that is stored as quickstart.py, but you
  can use any name you like. The quickstart example supports 3 environments:

  1. Oracle NoSQL Database Cloud Service
  2. Oracle NoSQL Cloud Simulator
  3. Oracle NoSQL Database on-premise, using the proxy server

  See `Running Quickstart`_ to
  run the quickstart program in different environments. The instructions assume
  that the *borneo* package has been installed.

  ``` python





































  import sys

  from borneo import (
      AuthorizationProvider, DeleteRequest, GetRequest,
      IllegalArgumentException, NoSQLHandle, NoSQLHandleConfig, PutRequest,
      QueryRequest, Regions, TableLimits, TableRequest)
  from borneo.iam import SignatureProvider
  from borneo.kv import StoreAccessTokenProvider






  cloud_region = Regions.EU_ZURICH_1
  cloudsim_endpoint = 'localhost:8080'
  kvstore_endpoint = 'localhost:80'
  cloudsim_id = 'cloudsim'  # a fake user id/namespace for the Cloud Simulator








  tenancy = None  # tenancy'd OCID (string)
  user = None  # user's OCID (string)
  private_key = 'path-to-private-key-or-private-key-content'
  fingerprint = 'fingerprint for uploaded public key'

  pass_phrase = None


  class CloudsimAuthorizationProvider(AuthorizationProvider):
      """
      Cloud Simulator Only.

      This class is used as an AuthorizationProvider when using the Cloud
      Simulator, which has no security configuration. It accepts a string
      tenant_id that is used as a simple namespace for tables.
      """

      def __init__(self, tenant_id):
          super(CloudsimAuthorizationProvider, self).__init__()
          self._tenant_id = tenant_id

      def close(self):
          pass

      def get_authorization_string(self, request=None):
          return 'Bearer ' + self._tenant_id


  def get_handle(nosql_env):
      """
      Returns a NoSQLHandle based on the requested environment. The
      differences among the supported environments are encapsulated in this
      method.
      """
      if nosql_env == 'cloud':
          endpoint = cloud_region
          
          
          
          
          
          if tenancy is not None:
              print('Using directly provided credentials')
              
              
              
              provider = SignatureProvider(tenant_id=tenancy,
                                           user_id=user,
                                           fingerprint=fingerprint,
                                           private_key=private_key,
                                           pass_phrase=pass_phrase)
          else:
              
              
              
              
              
              
              print('Using credentials and DEFAULT profile from ' +
                    '~/.oci/config')
              provider = SignatureProvider()
      elif nosql_env == 'cloudsim':
          print('Using cloud simulator endpoint ' + cloudsim_endpoint)
          endpoint = cloudsim_endpoint
          provider = CloudsimAuthorizationProvider(cloudsim_id)

      elif nosql_env == 'kvstore':
          print('Using on-premise endpoint ' + kvstore_endpoint)
          endpoint = kvstore_endpoint
          provider = StoreAccessTokenProvider()

      else:
          raise IllegalArgumentException('Unknown environment: ' + nosql_env)

      return NoSQLHandle(NoSQLHandleConfig(endpoint, provider))


  def main():

      table_name = 'PythonQuickstart'

      if len(sys.argv) != 2:
          print('Usage: python quickstart.py <cloud | cloudsim | kvstore>')
          raise SystemExit

      nosql_env = sys.argv[1:][0]
      print('Using environment: ' + str(nosql_env))

      handle = None
      try:

          
          
          
          handle = get_handle(nosql_env)

          
          
          
          statement = (
              'Create table if not exists {} (id integer, sid integer, ' +
              'name string, primary key(shard(sid), id))').format(table_name)
          request = TableRequest().set_statement(statement).set_table_limits(
              TableLimits(30, 10, 1))
          handle.do_table_request(request, 50000, 3000)
          print('After create table')

          
          
          
          request = PutRequest().set_table_name(table_name)
          for i in range(10):
              value = {'id': i, 'sid': 0, 'name': 'myname' + str(i)}
              request.set_value(value)
              handle.put(request)
          print('After put of 10 rows')

          
          
          
          request = GetRequest().set_key({'id': 1, 'sid': 0}).set_table_name(
              table_name)
          result = handle.get(request)
          print('After get: ' + str(result))

          
          
          
          statement = (
              'select * from ' + table_name + ' where id > 2 and id < 8')
          request = QueryRequest().set_statement(statement)
          print('Query results for: ' + statement)
          
          
          
          
          
          
          
          while True:
              result = handle.query(request)
              for r in result.get_results():
                  print('\t' + str(r))
              if request.is_done():
                  break

          
          
          
          request = DeleteRequest().set_table_name(table_name).set_key(
              {'id': 1, 'sid': 0})
          result = handle.delete(request)
          print('After delete: ' + str(result))

          
          
          
          request = GetRequest().set_key({'id': 1, 'sid': 0}).set_table_name(
              table_name)
          result = handle.get(request)
          print('After get (should be None): ' + str(result))

          
          
          
          request = TableRequest().set_statement(
              'drop table if exists {} '.format(table_name))
          result = handle.table_request(request)

          
          
          
          
          result.wait_for_completion(handle, 40000, 2000)
          print('After drop table')

          print('Quickstart is complete')
      except Exception as e:
          print(e)
      finally:
          
          if handle is not None:
              handle.close()


  if __name__ == '__main__':
      main()
  ```




  Running against the Cloud Service requires an Oracle Cloud account. See
  [Configure for the Cloud Service](https://nosql-python-sdk.readthedocs.io/en/stable/installation.html#configure-for-the-cloud-service) for information on
  getting an account and acquiring required credentials.

  1. Collect the following information:

   * Tenancy ID
   * User ID
   * API signing key (private key file in PEM format)
   * Fingerprint for the public key uploaded to the user's account
   * Private key pass phrase, needed only if the private key is encrypted

  2. Edit *quickstart.py* and add your information. There are 2 ways to supply
     credentials in the program:

     * Directly provide the credential information. To use this method, modify the
       values of the variables at the top of the program: *tenancy*, *user*,
       *private_key*, *fingerprint*, and *pass_phrase*, setting them to the
       corresponding information you've collected.
     * Using a configuration file. In this case the information you've collected
       goes into a file, ~/.oci/config. [Configure for the Cloud Service](https://nosql-python-sdk.readthedocs.io/en/stable/installation.html#configure-for-the-cloud-service) describes the contents of the file. It will look like
       this::

        [DEFAULT]
        tenancy=<your-tenancy-id>
        user=<your-user-id>
        fingerprint=<fingerprint-of-your-public-key>
        key_file=<path-to-your-private-key-file>
        pass_phrase=<optional-pass-phrase-for-key-file>

  3. Decide which region you want to use and modify the *cloud_region* variable to
     the desired region. See [Regions documentation](https://nosql-python-sdk.readthedocs.io/en/stable/api/borneo.Regions.html) for possible regions. Not
     all support the Oracle NoSQL Database Cloud Service.

  4. Run the program:

  .. code-block:: pycon

      python quickstart.py cloud



  Running against the Oracle NoSQL Cloud Simulator requires a running Cloud
  Simulator instance. See [Configure for the Cloud Simulator](https://nosql-python-sdk.readthedocs.io/en/latest/installation.html#configure-for-the-cloud-simulator) for information on how to
  download and start the Cloud Simulator.

  1. Start the Cloud Simulator based on instructions above. Note the HTTP port
     used. By default it is *8080* on *localhost*.

  2. The *quickstart.py* program defaults to *localhost:8080* so if the Cloud
     Simulator was started using default values no editing is required.

  3. Run the program:

  .. code-block:: pycon

      python quickstart.py cloudsim



  Running against the Oracle NoSQL Database on-premise requires a running Oracle
  NoSQL Database instance as well as a running NoSQL Proxy server instance. The
  program will connect to the proxy server.

  See [Configure for On-Premise Oracle NoSQL Database](https://nosql-python-sdk.readthedocs.io/en/latest/installation.html#configure-for-the-on-premise-oracle-nosql-database) for information on how to
  download and start the database instance and proxy server. The database and
  proxy should be started without security enabled for this quickstart program to
  operate correctly. A secure configuration requires a secure proxy and more
  complex configuration.

  1. Start the Oracle NoSQL Database and proxy server based on instructions above.
     Note the HTTP port used. By default the endpoint is *localhost:80*.

  2. The *quickstart.py* program defaults to *localhost:80*. If the proxy was
     started using a different host or port edit the settings accordingly.

  3. Run the program:

  .. code-block:: pycon

      python quickstart.py kvstore



  This project welcomes contributions from the community. Before submitting a pull request, please [review our contribution guide](./CONTRIBUTING.md)



  Please consult the [security guide](./SECURITY.md) for our responsible security vulnerability disclosure process



  Copyright (c) 2018, 2024 Oracle and/or its affiliates.

  Released under the Universal Permissive License v1.0 as shown at
  <https://oss.oracle.com/licenses/upl/>.


pkgId: 06c4c9e3483106c08959495a5c5f1a3f834d0f0fb4e6952a66d489fbc19058db
name: python-bornrule
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Implements the Born Classifier
url: https://github.com/eguidotti/bornrule
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bornrule-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This package implements the classifier proposed in the paper [Text Classification with Born's Rule](https://proceedings.neurips.cc/paper_files/paper/2022/hash/c88d0c9bea6230b518ce71268c8e49e0-Abstract-Conference.html). All code is available at the [GitHub repository](https://github.com/eguidotti/bornrule). The documentation is available [here](https://bornrule.eguidotti.com).


pkgId: 2bfb9a0106ee2899957fe322b0225457c370021a07090d8f6e19517ed42f64ee
name: python-borsh-construct
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Python implementation of Borsh serialization, built on the Construct library.
url: https://github.com/near/borsh-construct-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borsh-construct-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/near/borsh-construct-py/workflows/Tests/badge.svg)](https://github.com/near/borsh-construct-py/actions?workflow=Tests)
  [![Docs](https://github.com/near/borsh-construct-py/workflows/Docs/badge.svg)](https://near.github.io/borsh-construct-py/)

  `borsh-construct` is an implementation of the [Borsh](https://borsh.io/) binary serialization format for Python projects.

  Borsh stands for Binary Object Representation Serializer for Hashing. It is meant to be used in security-critical projects as it prioritizes consistency, safety, speed, and comes with a strict specification.

  Read the [Documentation](https://near.github.io/borsh-construct-py/).


  ```sh
  pip install borsh-construct

  ```




  1. Install [poetry](https://python-poetry.org/docs/#installation)
  2. Install dev dependencies:
  ```sh
  poetry install

  ```
  3. Install [nox-poetry](https://github.com/cjolowicz/nox-poetry) (note: do not use Poetry to install this, see [here](https://medium.com/@cjolowicz/nox-is-a-part-of-your-global-developer-environment-like-poetry-pre-commit-pyenv-or-pipx-1cdeba9198bd))
  4. Activate the poetry shell:
  ```sh
  poetry shell

  ```


  ```sh
  pytest

  ```


  ```sh
  nox

  ```


pkgId: eef6572a0ceadf87c9d88b312af060062cb6689314deb88adbadf8451506ca6a
name: python-borsh-python
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A Borsh library for Python 3.
url: https://github.com/whdev1/borsh-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-borsh-python-0.1.5-1.src.rpm
checksum_type: sha256
description:
  This is an unofficial Python library for serializing and deserializing data in the [Borsh](https://borsh.io/) binary serialization format.

  Borsh stands for *Binary Object Representation Serializer for Hashing.* It was originally implemented in Rust for use with the [Near protocol](https://near.org/) with a focus on "consistency, safety, and speed." It is used for serializing data in a number of applications, including the [Solana](https://solana.com) blockchain.


  This library can be installed using pip:

  ```
  pip install borsh-python
  ```


  All Borsh byte streams have a *schema* that specifies name and type pairs for each of the values in the stream. The names of the available types are based on Rust and may be found [on this page](https://borsh.io/#pills-specification).

  In this library, schemas may be declared as follows:

  ```Python
  import borsh
  from borsh import types


  example_dict = {
    'w': 123,
    'x': 30000,
    'y': 'hello',
    'z': [1, 2, 3, 4]
  }


  example_dict_schema = borsh.schema({
    'w': types.u8,
    'x': types.i16,
    'y': types.string,
    'z': types.dynamic_array(types.i8)
  })
  ```

  We can serialize `example_dict` by calling the `serialize` method and providing the schema:

  ```Python
  serialized_bytes = borsh.serialize(example_dict_schema, example_dict)

  print(serialized_bytes)

  ```

  This byte string can be deserialized by calling the `deserialize` method and providing the same schema:

  ```Python
  deserialized_data = borsh.deserialize(example_dict_schema, serialized_bytes)

  print(deserialized_data)

  ```

  Borsh data streams are often base64 encoded. This library can handle these streams when used in conjunction with the `base64` library. For example:

  ```Python
  import base64
  import borsh
  from borsh import types

  base64_borsh_data = base64.b64decode('ezB1BQAAAGhlbGxvBAAAAAECAwQ=')

  example_dict_schema = borsh.schema({
    'w': types.u8,
    'x': types.i16,
    'y': types.string,
    'z': types.dynamic_array(types.i8)
  })

  print(borsh.deserialize(example_dict_schema, base64_borsh_data))

  ```


  The Borsh format supports a `struct` type which is similar in function to its counterparts in C-family languages. Consider that we are trying to wrap our `example_dict` into a `struct`. We may declare our data and schema as follows:

  ```Python
  import borsh
  from borsh import types


  example_struct_dict = {
    'example': types.struct({
      'w': 123,
      'x': 30000,
      'y': 'hello',
      'z': [1, 2, 3, 4]
    })
  }


  example_struct_schema = {
    'example': types.struct({
      'w': types.u8,
      'x': types.i16,
      'y': types.string,
      'z': types.dynamic_array(types.i8)
    })
  }
  ```

  We may serialize and deserialize our `struct` like this:

  ```Python
  serialized_bytes = borsh.serialize(example_struct_schema, example_struct_dict)

  example_struct = borsh.deserialize(example_struct_schema, serialized_bytes)['example']
  print(example_struct['y'])

  ```


  This library supports the following Borsh types, each of which is mapped to a respective Python type during deserialization.

  | Borsh Type      | Python Type      |
  | --------------- | ---------------- |
  | `dynamic_array` | `List[type]`     |
  | `fixed_array`   | `List[type]`     |
  | `f32`           | `float`          |
  | `f64`           | `float`          |
  | `hashmap`       | `dict{k_t: v_t}` |
  | `hashset`       | `Set[type]`      |
  | `i8`            | `int`            |
  | `i16`           | `int`            |
  | `i32`           | `int`            |
  | `i64`           | `int`            |
  | `i128`          | `int`            |
  | `option(type)`  | `None` or `type` |
  | `string`        | `str`            |
  | `struct`        | `_struct[dict]`  |
  | `u8`            | `int`            |
  | `u16`           | `int`            |
  | `u32`           | `int`            |
  | `u64`           | `int`            |
  | `u128`          | `int`            |
  | `unit`          | `None`           |


  The following Borsh types are not yet implemented in this library:

  | Borsh Type      |
  | --------------- |
  | `enum`          |
  | `fields`        |
  | `named_fields`  |
  | `unnamed_fields`|


pkgId: d3ec655aff46967236b67fc319f871d2e331090cdc0b31edb2df7cd0cf523d21
name: python-bos-incidents
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Private module for BOS incident storage
url: http://pbsa.info
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bos-incidents-0.4.1-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/v/bos-incidents.svg?style=for-the-badge)
  ![](https://img.shields.io/github/downloads/pbsa/bos-incidents/total.svg?style=for-the-badge)
  ![](https://img.shields.io/pypi/pyversions/bos-incidents.svg?style=for-the-badge)

  [![docs master](https://readthedocs.org/projects/bos-incidents/badge/?version=latest)](http://bos-incidents.rtfd.io/en/latest/)
  [![docs develop](https://readthedocs.org/projects/bos-incidents/badge/?version=develop)](http://bos-incidents.rtfd.io/en/develop/)

  `bos-incidents` stores incidents from the data-proxies in a mongodb so
  it's status can be tracked and displayed via command line tools in
  `bos-incidents` or the web interface `bos-mint`.



  [![docs master](https://readthedocs.org/projects/bos-incidents/badge/?version=latest)](http://bos-incidents.rtfd.io/en/latest/)
  [![docs develop](https://readthedocs.org/projects/bos-incidents/badge/?version=develop)](http://bos-incidents.rtfd.io/en/develop/)


pkgId: 50ea4130ed132dc540f4f9a40f20b93e83b019c4bdf44d4fdd55a7296a81340a
name: python-bos-sync
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Synchronized objects on the blockchain using proposals wherenecessary
url: http://pbsa.info
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bos-sync-0.4.3-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/v/bos-sync.svg?style=for-the-badge)
  ![](https://img.shields.io/github/downloads/pbsa/bos-sync/total.svg?style=for-the-badge)
  ![](https://img.shields.io/pypi/pyversions/bos-sync.svg?style=for-the-badge)

  [![docs master](https://readthedocs.org/projects/bos-sync/badge/?version=latest)](http://bos-sync.rtfd.io/en/latest/)
  [![docs develop](https://readthedocs.org/projects/bos-sync/badge/?version=develop)](http://bos-sync.rtfd.io/en/develop/)

  The purpose of this library is to simplify the dealing with proposals
  when creating or updating objects, such as sports and events on the
  blockchain, as well as abstracting the resolution and bookiesports
  integration away from high-level code.



  [![docs master](https://readthedocs.org/projects/bos-sync/badge/?version=latest)](http://bos-sync.rtfd.io/en/latest/)
  [![docs develop](https://readthedocs.org/projects/bos-sync/badge/?version=develop)](http://bos-sync.rtfd.io/en/develop/)


pkgId: a62daf13781a01ecec562d557f0303619f8d53ddf2ddf656e3d9dbc6216ab43b
name: python-bosch-control-panel-cc880p
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Library to interface with the old CC880p Bosch COntrol Panels
url: https://github.com/hgomes88/bosch-control-panel-cc880p
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bosch-control-panel-cc880p-4.0.0-1.src.rpm
checksum_type: sha256
description:
  1       C0          Hexadecimal representation of the 'Send Key' command
  2-8     k<n>        Each byte is represents the key of the keypad. Can be sent
                          from 1 up to 7 keys in a single command
  9       area        If the alarm is configured to have multiple areas, then
                          this byte identifies the target area that the key(s)
                          will be sent to. Otherwise set it to '00'.
  10      nKeys       Number of keys being sent in this command
  11      crc         Frame checksum (excluding the 1st byte)
  ```

  Command used to enable/disable the siren
  ```
  'Set Siren' Command
  0E <on> 00 00 00 00 00 00 00 00 <crc>


pkgId: 209c6e4cd0b50b4784ea911ea112febd1b68bd1ed099becf3c62a287bf92e809
name: python-bosch-thermostat-http-client
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Python API for talking to Bosch™ Heating gateway using HTTP
url: https://github.com/moustic999/bosch-thermostat-http-client-python.git
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bosch-thermostat-http-client-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Python3 asyncio package to talk to Bosch Thermostats via their gateway, especially for Buderus KM200/KM50 and Nefit IP modules used in Enviline heat pumps. These gateways support Http access in local network.

  example :
  ```python
  import asyncio
  import aiohttp

  from buderus.gateway import Gateway
  async def main():
      async with aiohttp.ClientSession() as session:
          gateway =  Gateway(session, '<Local IP of gateway>','<gateway password>','<user password>')
          await gateway.initialize()


          print(gateway.info.uuid)

          for sensor in gateway.sensors.items:
              print (sensor.name, sensor.value)

  asyncio.get_event_loop().run_until_complete(main())
  ```

  To run this code do the following:

  * create file data_file.txt and insert like this:
  ```
  ip
  access_key
  password
  ```
  replace strings with proper values

  * run in dir `python3 -m venv .`
  * run `python3 test.py`


  Now there is extra command added with this package `bosch_scan`.
  ```
  Usage: bosch_scan [OPTIONS] COMMAND [ARGS]...

    A tool to create rawscan of Bosch thermostat.

  Options:
    --ip TEXT                       IP address of gateway  [required]
    --token TEXT                    Token from sticker without dashes.
                                    [required]
    --password TEXT                 Password you set in mobile app.
    -o, --output TEXT               Path to output file of scan. Default to
                                    [raw/small]scan_uuid.json
    --stdout                        Print scan to stdout
    -d, --debug
    -s, --smallscan [HC|DHW|SENSORS]
                                    Scan only single circuit of thermostat.
    --help                          Show this message and exit.

  ```



  SENSORS:
  ```
  bosch_examples sensors --help
  bosch_examples sensors --ip {IP} --token {TOKEN} --password {PASS} -s outdoor_t1
  ```

  DHW:
  ```
  bosch_examples dhw --help
  bosch_examples dhw --ip {IP} --token {TOKEN} --password {PASS} -t --op_modes --setpoints -m
  ```

  HC:
  ```
  bosch_examples hc --help
  bosch_examples hc --ip {IP} --token {TOKEN} --password {PASS} -t --op_modes --setpoints -m
  ```


pkgId: 3b43324b6060d76463508561562c91eb02d1370162faea4dc26fdc6970bb4353
name: python-boschshcpy
arch: src
version: 0.2.95
epoch: 0
release: 1
summary: Bosch Smart Home Controller API Python Library
url: https://github.com/tschamm/boschshcpy
rpm_license: bsd-3-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boschshcpy-0.2.95-1.src.rpm
checksum_type: sha256
description:
  This library implements the local communication REST API for the Bosch Smart Home Controller system. It supports both long and short polling. The API documentation is available [here](https://github.com/BoschSmartHome/bosch-shc-api-docs).

  The following device services are implemented:

  * ```TemperatureLevel```
  * ```HumidityLevel```
  * ```RoomClimateControl```
  * ```ShutterContact```
  * ```ValveTappet```
  * ```PowerSwitch```
  * ```PowerMeter```
  * ```Routing```
  * ```PowerSwitchProgram```
  * ```PresenceSimulationConfiguration```
  * ```BinarySwitch```
  * ```SmokeDetectorCheck```
  * ```Alarm```
  * ```ShutterControl```
  * ```CameraLight```
  * ```PrivacyMode```
  * ```CameraNotification```
  * ```IntrusionDetectionControl```
  * ```Keypad```
  * ```LatestMotion```
  * ```AirQualityLevel```
  * ```SurveillanceAlarm```
  * ```BatteryLevel```
  * ```Thermostat```
  * ```WaterLeakageSensor```
  * ```WaterLeakageSensorTilt```
  * and more

  The following device models are implemented, using the above services:

  * ```ShutterContact```, ```ShutterContact2```
  * ```ShutterControl```, ```Micromodule Shutter```
  * ```SmartPlug```
  * ```SmartPlugCompact```
  * ```LightControl```, ```Micromodule Light Control```, ```Micromodule Light Attached```, ```Micromodule Relay```
  * ```SmokeDetector```
  * ```CameraEyes```, ```Camera360```
  * ```IntrusionDetectionSystem```
  * ```RoomClimateControl```
  * ```Thermostat```, ```Thermostat2```
  * ```WallThermostat```
  * ```UniversalSwitch```
  * ```MotionDetector```
  * ```PresenceSimulationSystem```
  * ```Twinguard```
  * ```WaterLeakageSensor```


  1. Install a `python` (>=3.10) environment on your computer.
  2. Install latest version of `boschshcpy`, you should have at least `version>=0.2.45`.
  ```bash
  pip install boschshcpy
  ```



  To register a new client, use the script `boschshc_registerclient`:
  ```bash
  boschshc_registerclient -ip _your_shc_ip_ -pw _your_shc_password_
  ```

  This will register your client and will write the associated certificate/key pair into your working directory. See also [Usage Guide](#usage-guide)



  To make a rawscan of your devices, use the script `boschshc_rawscan`


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ public_information
  ```


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ devices
  ```


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ device _your_device_id_
  ```

  An exemplary output looks as follows:
  ```bash
      {
          "@type": "device",
          "rootDeviceId": "xx-xx-xx-xx-xx-xx",
          "id": "hdm:HomeMaticIP:30xxx",
          "deviceServiceIds": [
              "Thermostat",
              "BatteryLevel",
              "ValveTappet",
              "SilentMode",
              "TemperatureLevel",
              "Linking",
              "TemperatureOffset"
          ],
          "manufacturer": "BOSCH",
          "roomId": "hz_8",
          "deviceModel": "TRV",
          "serial": "30xxx",
          "profile": "GENERIC",
          "name": "Test Thermostat",
          "status": "AVAILABLE",
          "parentDeviceId": "roomClimateControl_hz_8",
          "childDeviceIds": []
      },
  ```


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ device_services _your_device_id_
  ```

  The exemplary output will look as follows:
  ```bash
  [
      {
          "@type": "DeviceServiceData",
          "id": "BatteryLevel",
          "deviceId": "hdm:HomeMaticIP:30xxx",
          "path": "/devices/hdm:HomeMaticIP:30xxx/services/BatteryLevel"
      },
      {
          "@type": "DeviceServiceData",
          "id": "Thermostat",
          "deviceId": "hdm:HomeMaticIP:30xxx",
          "state": {
              "@type": "childLockState",
              "childLock": "OFF"
          },
          "path": "/devices/hdm:HomeMaticIP:30xxx/services/Thermostat"
      },
  ...
  ]
  ```


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ device_service _your_device_id_ _your_service_id
  ```


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ scenarios
  ```


  ```bash
  boschshc_rawscan -ip _your_shc_ip_ -cert _your_shc_cert_file_ -key _your_shc_key_file_ rooms
  ```



  ```python
  import boschshcpy


  session = boschshcpy.SHCSession(controller_ip="192.168.25.51", certificate='cert.pem', key='key.pem')
  session.information.summary()

  device = session.device('roomClimateControl_hz_5')
  service = device.device_service('TemperatureLevel')
  print(service.temperature)


  service.short_poll()


  session.start_polling()


  ...


  session.stop_polling()


  intrusion_control = session.intrusion_system
  intrusion_control.arm()


  scan_result = session.rawscan(command="devices")
  ```



  Before accessing the Bosch Smart Home Controller, a client must be registered on the controller. For this a valid cert/key pair must be provided to the controller. To start the client registration, press and hold the button on the controller until the led starts flashing. More information [here](https://github.com/BoschSmartHome/bosch-shc-api-docs/tree/master/postman#register-a-new-client-to-the-bosch-smart-home-controller).


pkgId: 893329ed96c646c127dd16cf33ca9a0361fc8315fb86ff9265f8babea2ead4d5
name: python-bosdyn-api
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Boston Dynamics API definition of protobuf messages
url: https://dev.bostondynamics.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bosdyn-api-4.1.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.

  Downloading, reproducing, distributing or otherwise using the SDK Software
  is subject to the terms and conditions of the Boston Dynamics Software
  Development Kit License (20191101-BDSDK-SL).
  -->



  <p align="center">
  <img src="https://www.bostondynamics.com/sites/default/files/2020-05/spot.png" style="max-width:50%;">
  </p>

  The bosdyn-api wheel contains the Python implementation for the Protobuf definitions in the Boston
  Dynamics Spot API. The message and service types defined in this wheel are used by the clients in
  [bosdyn-client](https://pypi.org/project/bosdyn-client/),
  [bosdyn-mission](https://pypi.org/project/bosdyn-mission/) and [bosdyn-choreography-client](https://pypi.org/project/bosdyn-choreography-client/) wheels to communicate with the services
  running on the Spot robots.


pkgId: 8d8265795c2510efd4f974b2b63dc93d0954426b563c369bf4721f3163c6fd39
name: python-bosdyn-choreography-protos
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Boston Dynamics API Choreography protobufs
url: https://dev.bostondynamics.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bosdyn-choreography-protos-4.1.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.

  Downloading, reproducing, distributing or otherwise using the SDK Software
  is subject to the terms and conditions of the Boston Dynamics Software
  Development Kit License (20191101-BDSDK-SL).
  -->



  <p align="center">
  <img src="https://www.bostondynamics.com/sites/default/files/2020-05/spot.png" style="max-width:50%;">
  </p>

  The bosdyn-choreography-protos wheel has been deprecated. The Python implementation for the Protobuf definitions previously stored in this build has been integrated with the [bosdyn-api wheel](https://pypi.org/project/bosdyn-api/).


pkgId: aec1e76b232fd24fab4e2afb4912a86eeac60d33d804647ddf59346fddacc422
name: python-bose
arch: src
version: 2.0.22
epoch: 0
release: 1
summary: The Ultimate Web Scraping Framework
url: https://pypi.org/project/bose/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bose-2.0.22-1.src.rpm
checksum_type: sha256
description:
  Bot Development is Tough.
  Bot Detectors like Cloudflare are ready to defend websites from our
  Bots. Configuring Selenium with ChromeOptions to specify the driver
  path, profile, user agent, and window size is Cumbersome and a nightmare
  in windows. Debugging Bot Crashes via logs is hard. How do you solve
  these pain points without sacrificing speed and handy development?
  Enter Bose. Bose is the first bot development framework in the Developer
  Community that is specifically designed to provide the best developer
  experience for bot developers. Powered by Selenium, it offers a range of
  features and functionalities to simplify the process of bot development.
  As far as our knowledge goes, Bose is the first bot development
  framework of its kind in the town.


pkgId: 3b01fb33d1958d3560859e27371a8a8cf86f7bf5254af7c2aa59eb496f98f308
name: python-bosonic-qiskit
arch: src
version: 13.1
epoch: 0
release: 1
summary: National Quantum Initiative Co-design Center for Quantum Advantage bosonic Qiskit simulator
url: https://github.com/C2QA/bosonic-qiskit
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bosonic-qiskit-13.1-1.src.rpm
checksum_type: sha256
description:
  NQI C2QA project to simulate hybrid boson-qubit systems within QisKit.



  Use a Python virtual environment to install compatible version of QisKit.

  ```bash
  git clone https://github.com/C2QA/bosonic-qiskit.git
  cd bosonic-qiskit
  ./install-dependencies.sh
  ```



  The Bosonic Qiskit software has not been extensively tested with different versions of its [dependencies](requirements.txt); however, some success has been achieved with both newer and older versions of Qiskit. Do note that some features require newer versions. For example, the noise modelling requires Qiskit v0.34.2+. Using older versions will cause `ModuleNotFoudError` at runtime.



  Before using Bosonic Qiskit, first install the depencies (as above) and then activate the Python virtual environment.

  ```bash
  cd <path/to/bosonic-qiskit>
  source venv/bin/activate
  ```



  Jupyter Notebook tutorials can be found in the [tutorials](tutorials) folder. JupyterLab is a dependency found in [requirements.txt](requirements.txt), so after installing and activating the virtual environment, to run the tutorials simply start Jupyter with `jupyter lab` and then navigate to the desired tutorial.

  See our paper presented at IEEE HPEC 2022 on [arXiv](https://arxiv.org/abs/2209.11153) for more information on using bosonic-qiskit.



  The code is structured to separate generation of the operator matrices from creating instances of QisKit Gate.

  The first step in adding a new gate is to develop software to build a unitary operator matrix. These matrices must be unitary in order for QisKit to simulate them. Non unitary matrices will fail during simulation. Existing operator matrices are built in the CVOperators class found in [operators.py](c2qa/operators.py). Included in CVOperators are functions to build the bosonic creation and annihilation operators based on a provided cutoff. The order of the data in your operators must match the order of the qumodes (QisKit qubits) sent in as QisKit gate parameters found in [circuit.py](c2qa/circuit.py), as described next.

  Once you've written software to build the operator matrix, a new function is added to the CVCircuit class found in [circuit.py](c2qa/circuit.py). This class extends the QisKit QuantumCircuit class to add the bosonic gates available in this library. The previusly defined operators are parameterized by user input, as needed, and appended to the QuantumCircuit as unitary gates. The CVCircuit class includes functions to easily make your new gates conditional based on a control qubit.

  See examples of software building new gates in the previously mentioned [operators.py](c2qa/operators.py) and [circuit.py](c2qa/circuit.py). Examples using the library's gates can be found in both the PyTest [test cases](tests) and Jupyter Notebook [tutorials](tutorials) folders



  Current gates available for simulation are documented at https://c2qa.github.io/bosonic-qiskit/c2qa.circuit.CVCircuit.html

rpm_license:
  Copyright 2022 Battelle Memorial Institute  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.  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: 5b2d91033598266bb11b9602095cdf2303cb52d76e7430298c6108abb18e442b
name: python-boss-cli
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Yet another pythonic deployment tool built on top of fabric.
url: https://github.com/kabirbaidhya/boss-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-boss-cli-1.0.3-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <a href="https://github.com/kabirbaidhya/boss-cli">
      <img style="width: 128px;" src="assets/boss.svg">
    </a>
    <br/>



  [![Travis branch](https://img.shields.io/travis/kabirbaidhya/boss/master.svg?style=flat-square)](https://travis-ci.org/kabirbaidhya/boss)
  [![PyPI](https://img.shields.io/pypi/v/boss-cli.svg?style=flat-square)](https://pypi.python.org/pypi/boss-cli)
  [![PyPI](https://img.shields.io/pypi/l/boss-cli.svg?style=flat-square)](https://github.com/kabirbaidhya/boss/blob/master/LICENSE)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](CONTRIBUTING.md)

  Yet another pythonic deployment tool built on top of [paramiko](http://www.paramiko.org/) and [fabric](http://www.fabfile.org/).

  Deploy like a boss.

  </div>



  ```bash
  $ pip install boss-cli==1.0.3
  ```



  Check the [configuration](docs/configuration.md) page.



  Custom scripts are scripts/commands that could be defined directly in the config file without having to write any line of python in the `fabfile.py`. They're similar to the [npm scripts](https://docs.npmjs.com/misc/scripts), if you're familiar with them.

  You can define the custom scripts under the `scripts` field in the `boss.yml`.

  **For instance:**

  ```yaml

  stages:
    prod:
      host: your-server.com
      public_url: 'https://your-server.com'
      branch: master

  scripts:
    hello: 'echo "Hello World!"'
    build: npm run build
    logs: pm2 logs
  ```

  Boss comes out of the box with a task `run` which you can use to run these scripts on the remote server like this:

  ```bash
  $ fab prod run:hello
  $ fab prod run:build
  $ fab prod run:logs
  ```





  This is a generic deployment preset, where the remote host also contains the project source code and the git repository. The deploy task would synchronize the remote with the latest changes of the provided branch from the origin. It then builds the project and restarts the service if needed.

  This is general and language agnostic so it can be used for deploying any kind of project. You just need to specify the relevant `build` script to build your project in the remote and if it requires service restart then you'll need to define a `reload` script as well.

  You'll need to set the deployment preset as `remote-source` in your configuration.

  ```yml
  deployment:
    preset: remote-source
  ```



  Your `boss.yml` file for remote source deployment would look similar to this:

  ```yml
  project_name: my-app
  project_description: 'My App'
  repository_url: 'https://github.com/username/repository'
  branch_url: '{repository_url}/tree/{branch}'
  user: deploy_user

  deployment:
    preset: remote-source
    base_dir: /source/my-app

  stages:
    prod:
      host: your-server.com
      public_url: 'https://your-server.com'
      branch: master

  scripts:
    install: 'npm install'
    build: 'npm run build'
    start: 'pm2 start dist/myapp.js'
    stop: 'pm2 stop dist/myapp.js'
    reload: 'pm2 reload dist/myapp.js'

  notifications:
    slack:
      enabled: true
      endpoint: ${BOSS_SLACK_ENDPOINT}
  ```

  The above configuration is specific to a [Node.js](https://nodejs.org/en/) project environment, but you can also deploy projects built with other languages like PHP, Python, Java etc. All you need to do is change the scripts `install`, `build`, `reload`.



  You can check the available tasks for `remote-source` preset with `fab --list`.

  ```bash
   ➜ fab --list

  Available commands:

      build    Build the application.
      check    Check the current remote branch and the last commit.
      deploy   Deploy to remote source.
      prod     Configures the prod server environment.
      logs     Tail the logs.
      restart  Restart the service.
      run      Run a custom script.
      status   Check the status of the service.
      stop     Stop the service.
      sync     Sync the changes on the branch with the remote (origin).
  ```



  Now to deploy the the application to the `prod` server that you've configured in the `stages` above. You can do:

  ```bash
   ➜ fab prod deploy
  ```

  This would deploy the default branch `master` in this case. You can also provide a specific branch to deploy, as follows:

  ```bash
   ➜ fab prod deploy:branch=my-branch
  ```



  This deployment is useful for deploying the web apps (React, Angular, Vue etc) or static files to the remote server. This preset assumes the static files are served via a web server on the remote host eg: nginx, apache etc. Here, the source code is built locally and only the `dist` or `build` is uploaded and deployed to the server.

  The deployment process is zero-downtime, just like [capistrano](https://github.com/capistrano/capistrano).

  You'll need to set the deployment preset as `web` in your configuration.

  ```yml
  deployment:
    preset: web
  ```



  Your `boss.yml` file for web deployment would look similar to this:

  ```yml
  project_name: my-app
  project_description: 'My App'
  repository_url: 'https://github.com/username/repository'
  branch_url: '{repository_url}/tree/{branch}'
  user: deploy_user

  deployment:
    preset: web
    build_dir: build/           # The local build directory
    base_dir: /app/deployment   # The remote base directory for deployment.

  stages:
    prod:
      host: your-server.com
      public_url: 'https://your-server.com'

  scripts:
    install: 'npm install'
    build: 'npm run build'

  notifications:
    slack:
      enabled: true
      endpoint: ${BOSS_SLACK_ENDPOINT}
  ```

  The above configuration would work for any kind of web projects as long as it generates the build in static files (HTML, CSS, JS, media) that could be served via a web server.

  You can define two scripts `install` and `build` in your `boss.yml`, to install project dependencies and build the source respectively. For instance: if you've created your application using [`create-react-app`](https://github.com/facebookincubator/create-react-app), you can set these to `npm install` and `npm run build` as shown in above config.

  You also have to set the location of the output directory for the `build` script as `deployment.build_dir`. In our case, this would be the `build/` directory.



  You can check the available tasks for this preset with `fab --list`.

  ```bash
   ➜ fab --list

  Available commands:

      build      Build the code locally.
      buildinfo  Print the build information.
      builds     Display the build history.
      deploy     Zero-Downtime deployment for the web.
      info       Print the build information.
      logs       Tail the logs.
      rollback   Zero-Downtime deployment rollback for the web.
      run        Run a custom script.
      setup      Setup remote host for deployment.
      prod       Configures the prod server environment.
  ```



  For the first time, you can configure the remote host for deployment using the `setup` task.

  ```bash
   ➜ fab prod setup
  ```

  This will create necessary files and directories on the remote under the provided `base_dir` path. In our case the base directory will be `/app/deployment`.

  Once, the `setup` task completes you should see a message like this:

  ```
  Remote is setup and is ready for deployment.

  Deployed build will point to /app/deployment/current.
  For serving the latest build, please set your web server document root to /app/deployment/current.
  ```

  Now you'll need to set your web server document root on the remote host to the `current` symlink created under the `base_dir` path. This symlink will point to the latest build when you deploy your app.



  If you're using a web server like nginx, you can set the document root like this:

  ```

  server {
    listen 80;
    listen [::]:80;

    
    root /app/deployment/current;

    index index.html;
    ...
  }
  ```



  You can use the `deploy` task to deploy the app to the remote server.

  Here, first the `deploy` task would trigger the `install` and `build` scripts to build the project locally, after which the built directory configured in `deployment.build_dir` would be tar-zipped and uploaded to the remote host via SSH.

  So, to deploy current local source code to `prod` server you should do the following:

  ```bash
   ➜ fab prod deploy
  ```

  If you're using `git` in your project, you need to make sure you did `checkout` to the branch you want to deploy and is up to date. Like this,

  ```bash
   
   ➜ git checkout master
   ➜ fab prod deploy
  ```



  Node.js Project Deployment.
  More information, examples and documentation coming soon :).



  * [Capistrano](https://github.com/capistrano/capistrano)
  * [Fabric](http://www.fabfile.org/)



  Special Thanks to [Shirish Shikhrakar](https://github.com/sshikhrakar) for the [logo](https://github.com/kabirbaidhya/boss/tree/dev/assets).



  All kinds of contributions are welcome. Read our [contributing guide](CONTRIBUTING.md) to learn about our development process, how to propose PRs, report bugs and suggest improvements.



  Check the [CHANGELOG](CHANGELOG.md) for full release history.



  Licensed under [The MIT License](LICENSE).


pkgId: ba9369495904c007fe1b0ac2a00bec10b3015beac7a828e722e5e401fd6f1a70
name: python-bot-bin
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Shared cogs and utilities for use in Discord bots
url: https://github.com/ioistired/bot-bin
rpm_license: BlueOak-1.0.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bot-bin-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Shared cogs and utilities for use in Discord bots.
  Some cogs require bot configuration; those that do expect a `bot.config` dict attribute.



  Contains an AutoShardedBot subclass. Contains custom error logging, customizable on_message bot ignoring,
  case insensitive prefixes, and database setup if the setup_db kwarg is set to True. Requires the config kwarg
  to be set to a dict. bot.config['tokens']['discord'] should be the bot's Discord token.



  Contains memory usage and performance debugging commands. Most other debug functionality is already provided
  by [jishaku](https://pypi.org/project/jishaku/).



  Contains an uptime, ping, and copyright command. The latter requires bot.config['copyright_license_file'] to be
  set to a path to a text file, the contents of which will be sent when the user runs the copyright command.

  Also contains various utilities:
  - `codeblock` wraps text in a markdown code block
  - `absolute_natural_timedelta` returns an English string representing an amount of seconds
  - `natural_timedelta` returns an English string representing the difference between two dates.
    This function differs from `absolute_natural_timedelta` in that it also supports years and months.
  - `natural_rate` returns an English string representing a rate of occurence.
  - `plural` is a format object which pluralizes strings. For example: `f'Found {plural(len(results)):weapon}'`
  - `natural_join` joins a sequence of strings according to English grammar
  - `timeit` is a context manager that times the code in the `with` block



  Contains SQL execution commands for asyncpg.
  Requires `bot.pool` to be set to either an asyncpg Connection or a ConnectionPool.
  Requires the `bot_bin[sql]` extra.



  Implements the guild count API for DBL, DBots, Bots For Discord, LBots, and Discord Boats.
  This is configured using `bot.config['tokens']['stats']`.
  Each key should be a domain, e.g. `bot.config['tokens']['stats']['discordbots.org']` would be the bot's DBL token.

  Defines a `send-stats` owner only command which sends the current guild counts to the configured APIs
  and reports any errors.


pkgId: 278c538860dd01e8ab8da10c4f4ad49c58eeab809c5cc253f38c5b508a681fa6
name: python-bot-hosting-wrapper
arch: src
version: 1.2
epoch: 0
release: 1
summary: A simple API Wrapper for bot-hosting.net
url: https://suspectedesp.github.io/bhw-site/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bot-hosting-wrapper-1.2-1.src.rpm
checksum_type: sha256
description:
  This README will probably only work on github, not pypi, idk why

  Important: Your account token expires every 2 weeks! If something isnt working, make sure you use an up-to-date Auth ID :)

  A simple API Wrapper for certain information in python for bot-hosting.net

  This is made by @suspectedesp on discord, an ex-staff member of bot-hosting.net

  What a blessing that pdactyl exists

  - [Installation](#installation)
  - [Usage](#usage)
  - [Change Log](#changelog)
  - [License](#license)
  - [Contribution](#contributing)
  - [Credits](#credits)


  Dependencies (+ used version) :
  - requests==2.31.0
  - colorama==0.4.6
  - datetime==5.4



  Please follow the instructions to get your auth id:
  - Login to your account and go to [this page](https://bot-hosting.net/panel/)
  - Open your browser's console (usually by pressing F12 or pressing Control + Shift + I)
  - Navigate to the 'Console' tab
  - Paste in the following code:
  ```js
  var token = localStorage.getItem('token');
  console.log('Your Auth ID:', token);
  ```
  Now you got your Auth ID and can use all the scripts, congrats!

  For an usage of the commands etc. please go [to this page](https://github.com/suspectedesp/bot-hosting-wrapper/wiki/Coding-Usage)


  Latest Changelog:
  - Fixed Stupid Bugs
  - Tested & rewritten for optimization & automation
  - Updated the latest README & Usage Wiki & EXAMPLES


  MIT License

  Copyright (c) 2024 [redacted]

  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.


  - Follow these simple steps for contributing via [Github](https://github.com/suspectedesp/bot-hosting-wrapper)
  - Fork the repository.
  - Create a new branch: git checkout -b feature/my-feature.
  - Commit your changes: git commit -am 'Add my feature'.
  - Push to the branch: git push origin feature/my-feature.
  - Submit a pull request.


  Many thanks to:
  - @mathiasDPX for giving me some ideas and remaking the code
  - @pondwader for letting me upload this
  - @iamkubi api wrapper for pterodactyl panel

  Many thanks guys! I appreciate it <3


pkgId: c8028f8df1519430ef4869d89fa9cda5815e2574d93fde99f22d30a5173515df
name: python-bot-safe-agents
arch: src
version: 1.0
epoch: 0
release: 1
summary: A library for fetching a list of bot-safe user agents.
url: https://github.com/ivan-sincek/bot-safe-agents
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bot-safe-agents-1.0-1.src.rpm
checksum_type: sha256
description:
  A library for fetching a list of bot-safe user agents.

  Made for educational purposes. I hope it will help!



  * [How to Install](#how-to-install)
  	* [Standard Install](#standard-install)
  	* [Build and Install From the Source](#build-and-install-from-the-source)
  * [Usage](#usage)





  ```bash
  pip3 install bot-safe-agents

  pip3 install --upgrade bot-safe-agents
  ```



  Run the following commands:

  ```bash
  git clone https://github.com/ivan-sincek/bot-safe-agents && cd bot-safe-agents

  python3 -m pip install --upgrade build

  python3 -m build

  python3 -m pip install dist/bot-safe-agents-1.0-py3-none-any.whl
  ```



  Get all user agents:

  ```python
  import bot_safe_agents

  user_agents = bot_safe_agents.get_all()
  print(user_agents)


  ```

  Get a random user agent:

  ```python
  import bot_safe_agents

  user_agents = bot_safe_agents.get_random()
  print(user_agents)


  ```


pkgId: 1860cc845ec77430bee1b9788c99c081262bd4039ed49abedeb7fe3653e0fa21
name: python-botable
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Record and play keyboard and mouse clicks
url: http://github.com/ebonnal/botable
rpm_license: Apache 2.
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-botable-0.0.6-1.src.rpm
checksum_type: sha256
description:
  > Record and play keyboard and mouse clicks

  [![Actions Status](https://github.com/ebonnal/botable/workflows/unittest/badge.svg)](https://github.com/ebonnal/botable/actions)
  [![Actions Status](https://github.com/ebonnal/botable/workflows/PyPI/badge.svg)](https://github.com/ebonnal/botable/actions)


  ```bash
  pip install botable
  ```


  ```python
  from botable import record, play


  recorded_events = list(record())




  played_events = list(play(recorded_events, loops=3))
  ```

  Help:
  ```python
  help(record)
  help(play)
  ```


  Here is the same scenario but using the command line interface:
  ```bash

  python -m botable record > /tmp/recorded_events.py




  cat ./recorded_events.py | python -m botable play --playback-loops 3 > /tmp/played_events.py
  ```

  Help:
  ```bash
  python -m botable --help
  ```


  Press **f1** to stop the recording/playback. This is configurable, for example if you prefer to press *escape*:

  lib:
  ```python
  play(recorded_events, exit_key="esc")
  ```
  cli:
  ```bash
  python -m botable [play/record] --exit-key esc
  ```


  Press **f2** to pause/resume the recording/playback. This is configurable, for example if you prefer to press *space*:

  lib:
  ```python
  play(recorded_events, pause_key="space")
  ```
  cli:
  ```bash
  python -m botable [play/record] --pause-key space
  ```


pkgId: a487e940d65273fdaaf684ff7b59c2fb839bea827981c3474ddd07a6cc53ba04
name: python-botasaurus
arch: src
version: 4.0.73
epoch: 0
release: 1
summary: The All in One Web Scraping Framework
url: https://pypi.org/project/botasaurus/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-botasaurus-4.0.73-1.src.rpm
checksum_type: sha256
description:
  Also, by default, whenever the program ends or is canceled, Botasaurus smartly closes any open Chrome instances, leaving no instances running in the background.
  In rare cases, you may want to explicitly close the Chrome instance. For such scenarios, you can use the `.close()` method on the scraping function:
  ```python
  scrape_data.close()
  ```
  This will close any Chrome instances that remain open after the scraping function ends.

  Recently, we had a project requiring access to around 100,000 pages from a well-protected website, necessitating the use of Residential Proxies.
  Even after blocking images, we still required 250GB of proxy bandwidth, costing approximately $1050 (at $4.2 per GB with IP Royal).
  This was beyond our budget :(
  To solve this, we implemented a smart strategy:
  - We first visited the website normally.
  - We then made requests for subsequent pages using the browser's `fetch` API.
  Since we were only requesting the HTML, which was well compressed by the browser, we reduced our proxy bandwidth needs to just 5GB, costing only $30.
  This resulted in savings of around $1000!
  Here's an example of how you can do something similar in Botasaurus:
  ```python
  from botasaurus.browser import browser, Driver
  from botasaurus.soupify import soupify
  @browser(
      reuse_driver=True,  # Reuse the browser
      max_retry=5,        # Retry up to 5 times on failure
  )
  def scrape_data(driver: Driver, link):
      
      if driver.config.is_new:
          driver.google_get(link, bypass_cloudflare=True)
      
      response = driver.requests.get(link)
      response.raise_for_status()  # Ensure the request was successful
      html = response.text
      
      heading = soupify(html).select_one('.product-head__title [itemprop="name"]').get_text()
      return {
          "heading": heading,
      }

  links = [
      "https://www.g2.com/products/stack-overflow-for-teams/reviews",
      "https://www.g2.com/products/jenkins/reviews",
      "https://www.g2.com/products/docker-inc-docker/reviews",
  ]

  scrape_data(links)
  ```
  Note:
  1. **Dealing with 429 (Too Many Requests) Errors**
     If you encounter a 429 error, add a delay before making another request. Most websites using Nginx, setting a rate limit of 1 request per second. To respect this limit, a delay of 1.13 seconds is recommended.
     ```python
     driver.sleep(1.13)  # Delay to respect the rate limit
     response = driver.requests.get(link)
     ```
  2. **Handling 400 Errors Due to Large Cookies**
     If you encounter a 400 error with a "cookie too large" message, delete the cookies and retry the request.
     ```python
     response = driver.requests.get(link)
     if response.status_code == 400:
         driver.delete_cookies()  # Delete cookies to resolve the error
         driver.short_random_sleep()  # Short delay before retrying
         response = driver.requests.get(link)
     ```
  3. You can also use `driver.requests.get_mank(links)` to make multiple requests in parallel, which is faster than making them sequentially.

  The decorators in Botasaurus are really flexible, allowing you to pass a function that can derive the browser configuration based on the data item parameter. This is particularly useful when working with multiple Chrome profiles.
  You can dynamically configure the browser's Chrome profile and proxy using decorators in two ways:
  1. Using functions to extract configuration values from data:
     - Define functions to extract the desired configuration values from the `data` parameter.
     - Pass these functions as arguments to the `@browser` decorator.
     Example:
     ```python
     from botasaurus.browser import browser, Driver
     def get_profile(data):
         return data["profile"]
     def get_proxy(data):
         return data["proxy"]
     @browser(profile=get_profile, proxy=get_proxy)
     def scrape_heading_task(driver: Driver, data):
         profile, proxy = driver.config.profile, driver.config.proxy
         print(profile, proxy)
         return profile, proxy
     data = [
         {"profile": "pikachu", "proxy": "http://142.250.77.228:8000"},
         {"profile": "greyninja", "proxy": "http://142.250.77.229:8000"},
     ]
     scrape_heading_task(data)
     ```
  2. Directly passing configuration values when calling the decorated function:
     - Pass the profile and proxy values directly as arguments to the decorated function when calling it.
     Example:
     ```python
     from botasaurus.browser import browser, Driver
     @browser
     def scrape_heading_task(driver: Driver, data):
         profile, proxy = driver.config.profile, driver.config.proxy
         print(profile, proxy)
         return profile, proxy
     scrape_heading_task(
         profile='pikachu',  # Directly pass the profile
         proxy="http://142.250.77.228:8000",  # Directly pass the proxy
     )
     ```
  PS: Most Botasaurus decorators allow passing functions to derive configurations from data parameters. Check the decorator's argument type hint to see if it supports this functionality.

  To store data related to the active profile, use `driver.profile`. Here's an example:
  ```python
  from botasaurus.browser import browser, Driver
  def get_profile(data):
      return data["profile"]
  @browser(profile=get_profile)
  def run_profile_task(driver: Driver, data):
      
      driver.profile = {
          'name': 'Amit Sharma',
          'age': 30
      }
      
      driver.profile['name'] = 'Amit Verma'
      
      del driver.profile['age']
      
      print(driver.profile)  # Output: {'name': 'Amit Verma'}
      
      driver.profile = None
  run_profile_task([{"profile": "amit"}])
  ```
  For managing all profiles, use the `Profiles` utility. Here's an example:
  ```python
  from botasaurus.profiles import Profiles

  Profiles.set_profile('amit', {'name': 'Amit Sharma', 'age': 30})
  Profiles.set_profile('rahul', {'name': 'Rahul Verma', 'age': 30})

  profile = Profiles.get_profile('amit')
  print(profile)  # Output: {'name': 'Amit Sharma', 'age': 30}

  all_profiles = Profiles.get_profiles()
  print(all_profiles)  # Output: [{'name': 'Amit Sharma', 'age': 30}, {'name': 'Rahul Verma', 'age': 30}]

  random_profiles = Profiles.get_profiles(random=True)
  print(random_profiles)  # Output: [{'name': 'Rahul Verma', 'age': 30}, {'name': 'Amit Sharma', 'age': 30}] in random order

  Profiles.delete_profile('amit')
  ```
  Note: All profile data is stored in the `profiles.json` file in the current working directory.
  ![profiles](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/profiles.png)

  Botasaurus Driver provides several handy methods for web automation tasks such as:
  - Visiting URLs:
    ```python
    driver.get("https://www.example.com")
    driver.google_get("https://www.example.com")  # Use Google as the referer [Recommended]
    driver.get_via("https://www.example.com", referer="https://duckduckgo.com/")  # Use custom referer
    driver.get_via_this_page("https://www.example.com")  # Use current page as referer
    ```
  - For finding elements:
    ```python
    from botasaurus.browser import Wait
    search_results = driver.select(".search-results", wait=Wait.SHORT)  # Wait for up to 4 seconds for the element to be present, return None if not found
    all_links = driver.select_all("a")  # Get all elements matching the selector
    search_results = driver.wait_for_element(".search-results", wait=Wait.LONG)  # Wait for up to 8 seconds for the element to be present, raise exception if not found
    hello_mom = driver.get_element_with_exact_text("Hello Mom", wait=Wait.VERY_LONG)  # Wait for up to 16 seconds for an element having the exact text "Hello Mom"
    ```
  - Interact with elements:
    ```python
    driver.type("input[name='username']", "john_doe")  # Type into an input field
    driver.click("button.submit")  # Clicks an element
    element = driver.select("button.submit")
    element.click()  # Click on an element
    ```
  - Retrieve element properties:
    ```python
    header_text = driver.get_text("h1")  # Get text content
    error_message = driver.get_element_containing_text("Error: Invalid input")
    image_url = driver.select("img.logo").get_attribute("src")  # Get attribute value
    ```
  - Work with parent-child elements:
    ```python
    parent_element = driver.select(".parent")
    child_element = parent_element.select(".child")
    child_element.click()  # Click child element
    ```
  - Execute JavaScript:
    ```python
    result = driver.run_js("return document.title")
    text_content = element.run_js("(el) => el.textContent")
    ```
  - Working with iframes:
    ```python
    driver.get("https://www.freecodecamp.org/news/using-entity-framework-core-with-mongodb/")
    iframe = driver.get_iframe_by_link("www.youtube.com/embed")
    
    
    freecodecamp_youtube_subscribers_count = iframe.select(".ytp-title-expanded-subtitle").text
    ```
  - Execute CDP Command:
    ```python
    from botasaurus.browser import browser, Driver, cdp
    driver.run_cdp_command(cdp.page.navigate(url='https://stackoverflow.com/'))
    ```
  - Miscellaneous:
    ```python
    form.type("input[name='password']", "secret_password")  # Type into a form field
    container.is_element_present(".button")  # Check element presence
    page_html = driver.page_html  # Current page HTML
    driver.select(".footer").scroll_into_view()  # Scroll element into view
    driver.close()  # Close the browser
    ```

  To pause the scraper and wait for user input before proceeding, use `driver.prompt()`:
  ```python
  driver.prompt()
  ```

  Proxy providers like BrightData, IPRoyal, and others typically provide authenticated proxies in the format "http://username:password@proxy-provider-domain:port". For example, "http://greyninja:awesomepassword@geo.iproyal.com:12321".
  However, if you use an authenticated proxy with a library like seleniumwire to visit a website using Cloudflare like G2.com, you are GUARANTEED to be identified because you are using a non-SSL connection.
  To verify this, run the following code:
  First, install the necessary packages:
  ```bash
  python -m pip install selenium_wire chromedriver_autoinstaller_fix
  ```
  Then, execute this Python script:
  ```python
  from seleniumwire import webdriver
  from chromedriver_autoinstaller_fix import install

  proxy_options = {
      'proxy': {
          'http': 'http://username:password@proxy-provider-domain:port', # TODO: Replace with your own proxy
          'https': 'http://username:password@proxy-provider-domain:port', # TODO: Replace with your own proxy
      }
  }

  driver_path = install()
  driver = webdriver.Chrome(driver_path, seleniumwire_options=proxy_options)

  link = 'https://www.g2.com/products/github/reviews'
  driver.get("https://www.google.com/")
  driver.execute_script(f'window.location.href = "{link}"')

  input("Press Enter to exit...")

  driver.quit()
  ```
  You will SURELY be identified:
  ![identified](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/seleniumwireblocked.png)
  However, using proxies with Botasaurus solves this issue. See the difference by running the following code:
  ```python
  from botasaurus.browser import browser, Driver
  @browser(proxy="http://username:password@proxy-provider-domain:port") # TODO: Replace with your own proxy
  def scrape_heading_task(driver: Driver, data):
      driver.google_get("https://www.g2.com/products/github/reviews")
      driver.prompt()
  scrape_heading_task()
  ```
  Result:
  ![not identified](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/botasurussuccesspage.png)
  Important Note: To run the code above, you will need [Node.js](https://nodejs.org/en) installed.

  Certain proxy providers like BrightData will block access to specific websites. To determine if this is the case, run the following code:
  ```python
  from botasaurus.browser import browser, Driver
  @browser(proxy="http://username:password@proxy-provider-domain:port")  # TODO: Replace with your own proxy
  def visit_ipinfo(driver: Driver, data):
      driver.get("https://ipinfo.io/")
      driver.prompt()
  visit_ipinfo()
  ```
  If you can successfully access the ipinfo website but not the website you're attempting to scrape, it means the proxy provider is blocking access to that particular website.
  In such situations, the only solution is to switch to a different proxy provider.
  Some good proxy providers we personally use are:
  - For Rotating Datacenter Proxies: **BrightData Datacenter Proxies**, which cost around $0.6 per GB on a pay-as-you-go basis. No KYC is required.
  - For Rotating Residential Proxies: **IPRoyal Royal Residential Proxies**, which cost around $7 per GB on a pay-as-you-go basis. No KYC is required.
  As always, nothing good in life comes free. Proxies are expensive, and will take up almost all of your scraping costs.
  So, use proxies only when you need them, and prefer request-based scrapers over browser-based scrapers to save bandwidth.
  Note: BrightData and IPRoyal have not paid us. We are recommending them based on our personal experience.

  The United States is often the best choice because:
  - The United States has a highly developed internet infrastructure and is home to numerous data centers, ensuring faster internet speeds.
  - Most global companies host their websites in the US, so using a US proxy will result in faster scraping speeds.

  ONLY IF you encounter IP blocks.
  Sadly, most scrapers unnecessarily use proxies, even when they are not needed. Everything seems like a nail when you have a hammer.
  We have seen scrapers which can easily access hundreds of thousands of protected pages using the @browser module on home Wi-Fi without any issues.
  So, as a best practice scrape using the @browser module on your home Wi-Fi first. Only resort to proxies when you encounter IP blocks.
  This practice will save you a considerable amount of time (as proxies are really slow) and money (as proxies are expensive as well).

  The Request Decorator is used to make humane requests. Under the hood, it uses botasaurus-requests, a library based on hrequests, which incorporates important features like:
  - Using browser-like headers in the correct order.
  - Makes a browser-like connection with correct ciphers.
  - Uses `google.com` referer by default to make it appear as if the user has arrived from google search.
  Also, The Request Decorator allows you to configure proxy as follows:
  ```python
  @request(
      proxy="http://username:password@proxy-provider-domain:port"
  )
  ```

  All 3 decorators allow you to configure the following options:
  - Parallel Execution:
  - Caching Results
  - Passing Common Metadata
  - Asynchronous Queues
  - Asynchronous Execution
  - Handling Crashes
  - Configuring Output
  - Exception Handling
  Let's dive into each of these options and in later sections we will see their real-world applications.

  The `parallel` option allows you to scrape data in parallel by launching multiple browser/request/task instances simultaneously. This can significantly speed up the scraping process.
  Run the example below to see parallelization in action:
  ```python
  from botasaurus.browser import browser, Driver
  @browser(parallel=3, data=["https://www.omkar.cloud/", "https://www.omkar.cloud/blog/", "https://stackoverflow.com/"])
  def scrape_heading_task(driver: Driver, link):
      driver.get(link)
      heading = driver.get_text('h1')
      return heading
  scrape_heading_task()
  ```

  The `cache` option enables caching of web scraping results to avoid re-scraping the same data. This can significantly improve performance and reduce redundant requests.
  Run the example below to see how caching works:
  ```python
  from botasaurus.browser import browser, Driver
  @browser(cache=True, data=["https://www.omkar.cloud/", "https://www.omkar.cloud/blog/", "https://stackoverflow.com/"])
  def scrape_heading_task(driver: Driver, link):
      driver.get(link)
      heading = driver.get_text('h1')
      return heading
  print(scrape_heading_task())
  print(scrape_heading_task())  # Data will be fetched from cache immediately
  ```
  Note: Caching is one of the most important features of Botasaurus.

  The metadata option allows you to pass common information shared across all data items. This can include things like API keys, browser cookies, or any other data that remains constant throughout the scraping process.
  It is commonly used with caching to exclude details like API keys and browser cookies from the cache key.
  Here's an example of how to use the `metadata` option:
  ```python
  from botasaurus.task import task
  @task()
  def scrape_heading_task(driver: Driver, data, metadata):
      print("metadata:", metadata)
      print("data:", data)
  data = [
      {"profile": "pikachu", "proxy": "http://142.250.77.228:8000"},
      {"profile": "greyninja", "proxy": "http://142.250.77.229:8000"},
  ]
  scrape_heading_task(
    data,
    metadata={"api_key": "BDEC26..."}
  )
  ```

  In the world of web scraping, there are only two types of scrapers:
  1. Dataset Scrapers: These extract data from websites and store it as datasets. Companies like Bright Data use them to build datasets for Crunchbase, Indeed, etc.
  2. Real-time Scrapers: These fetch data from sources in real-time, like SERP APIs that provide Google and DuckDuckGo search results.
  When building real-time scrapers, speed is paramount because customers are waiting for requests to complete. The `async_queue` feature is incredibly useful in such cases.
  `async_queue` allows you to run scraping tasks asynchronously in a queue and gather the results using the `.get()` method.
  A great use case for `async_queue` is scraping Google Maps. Instead of scrolling through the list of places and then scraping the details of each place sequentially, you can use `async_queue` to:
  1. Scroll through the list of places.
  2. Simultaneously make HTTP requests to scrape the details of each place in the background.
  By executing the scrolling and requesting tasks concurrently, you can significantly speed up the scraper.
  Run the code below to see browser scrolling and request scraping happening concurrently (really cool, must try!):
  ```python
  from botasaurus.browser import browser, Driver, AsyncQueueResult
  from botasaurus.request import request, Request
  import json
  def extract_title(html):
      return json.loads(
          html.split(";window.APP_INITIALIZATION_STATE=")[1].split(";window.APP_FLAGS")[0]
      )[5][3][2][1]
  @request(
      parallel=5,
      async_queue=True,
      max_retry=5,
  )
  def scrape_place_title(request: Request, link, metadata):
      cookies = metadata["cookies"]
      html = request.get(link, cookies=cookies, timeout=12).text
      title = extract_title(html)
      print("Title:", title)
      return title
  def has_reached_end(driver):
      return driver.select('p.fontBodyMedium > span > span') is not None
  def extract_links(driver):
      return driver.get_all_links('[role="feed"] > div > div > a')
  @browser()
  def scrape_google_maps(driver: Driver, link):
      driver.google_get(link, accept_google_cookies=True)  # accepts google cookies popup
      scrape_place_obj: AsyncQueueResult = scrape_place_title()  # initialize the async queue for scraping places
      cookies = driver.get_cookies_dict()  # get the cookies from the driver
      while True:
          links = extract_links(driver)  # get the links to places
          scrape_place_obj.put(links, metadata={"cookies": cookies})  # add the links to the async queue for scraping
          print("scrolling")
          driver.scroll_to_bottom('[role="feed"]')  # scroll to the bottom of the feed
          if has_reached_end(driver):  # we have reached the end, let's break buddy
              break
      results = scrape_place_obj.get()  # get the scraped results from the async queue
      return results
  scrape_google_maps("https://www.google.com/maps/search/web+developers+in+bangalore")
  ```

  Similarly, the `run_async` option allows you to execute scraping tasks asynchronously, enabling concurrent execution.
  Similar to `async_queue`, you can use the `.get()` method to retrieve the results of an asynchronous task.
  Code Example:
  ```python
  from botasaurus.browser import browser, Driver
  from time import sleep
  @browser(run_async=True)
  def scrape_heading(driver: Driver, data):
      sleep(5)
      return {}
  if __name__ == "__main__":
      result1 = scrape_heading()  # Launches asynchronously
      result2 = scrape_heading()  # Launches asynchronously
      result1.get()  # Wait for the first result
      result2.get()  # Wait for the second result
  ```

  The `close_on_crash` option determines the behavior of the scraper when an exception occurs:
  - If set to `False` (default):
    - The scraper will make a beep sound and pause the browser.
    - This makes debugging easier by keeping the browser open at the point of the crash.
    - Use this setting during development and testing.
  - If set to `True`:
    - The scraper will close the browser and continue with the rest of the data items.
    - This is suitable for production environments when you are confident that your scraper is robust.
    - Use this setting to avoid interruptions and ensure the scraper processes all data items.
  ```python
  from botasaurus.browser import browser, Driver
  @browser(
      close_on_crash=False  # Determines whether the browser is paused (default: False) or closed when an error occurs
  )
  def scrape_heading_task(driver: Driver, data):
      raise Exception("An error occurred during scraping.")
  scrape_heading_task()
  ```

  By default, Botasaurus saves the result of scraping in the `output/{your_scraping_function_name}.json` file. Let's learn about various ways to configure the output.
  1. **Change Output Filename**: Use the `output` parameter in the decorator to specify a custom filename for the output.
  ```python
  from botasaurus.task import task
  @task(output="my-output")
  def scrape_heading_task(data):
      return {"heading": "Hello, Mom!"}
  scrape_heading_task()
  ```
  2. **Disable Output**: If you don't want any output to be saved, set `output` to `None`.
  ```python
  from botasaurus.task import task
  @task(output=None)
  def scrape_heading_task(data):
      return {"heading": "Hello, Mom!"}
  scrape_heading_task()
  ```
  3. **Dynamically Write Output**: To dynamically write output based on data and result, pass a function to the `output` parameter:
  ```python
  from botasaurus.task import task
  from botasaurus import bt
  def write_output(data, result):
      json_filename = bt.write_json(result, 'data')
      excel_filename = bt.write_excel(result, 'data')
      bt.zip_files([json_filename, excel_filename]) # Zip the JSON and Excel files for easy delivery to the customer
  @task(output=write_output)
  def scrape_heading_task(data):
      return {"heading": "Hello, Mom!"}
  scrape_heading_task()
  ```
  4. **Upload File to S3**: Use `bt.upload_to_s3` to upload file to S3 bucket.
  ```python
  from botasaurus.task import task
  from botasaurus import bt
  def write_output(data, result):
      json_filename = bt.write_json(result, 'data')
      bt.upload_to_s3(json_filename, 'my-magical-bucket', "AWS_ACCESS_KEY", "AWS_SECRET_KEY")
  @task(output=write_output)
  def scrape_heading_task(data):
      return {"heading": "Hello, Mom!"}
  scrape_heading_task()
  ```
  5.**Save Outputs in Multiple Formats**: Use the `output_formats` parameter to save outputs in different formats like JSON and EXCEL.
  ```python
  from botasaurus.task import task
  @task(output_formats=[bt.Formats.JSON, bt.Formats.EXCEL])
  def scrape_heading_task(data):
      return {"heading": "Hello, Mom!"}
  scrape_heading_task()
  ```
  PRO TIP: When delivering data to customers, provide the dataset in JSON and Excel formats. Avoid CSV unless the customer asks, because Microsoft Excel has a hard time rendering CSV files with nested JSON.
  **CSV vs Excel**
  ![csv-vs-excel](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/csv-vs-excel.png)

  Botasaurus provides various exception handling options to make your scrapers more robust:
  - `max_retry`: By default, any failed task is not retried. You can specify the maximum number of times to retry scraping when an error occurs using the `max_retry` option.
  - `retry_wait`: Specifies the waiting time between retries.
  - `raise_exception`: By default, Botasaurus does not raise an exception when an error occurs during scraping, because let's say you are keeping your PC running overnight to scrape 10,000 links. If one link fails, you really don't want to stop the entire scraping process, and ruin your morning by seeing an unfinished dataset.
  - `must_raise_exceptions`: Specifies exceptions that must be raised, even if `raise_exception` is set to `False`.
  - `create_error_logs`: Determines whether error logs should be created when exceptions occur. In production, when scraping hundreds of thousands of links, it's recommended to set `create_error_logs` to `False` to avoid using computational resources for creating error logs.
  ```python
  @browser(
      raise_exception=True,  # Raise an exception and halt the scraping process when an error occurs
      max_retry=5,  # Retry scraping a failed task a maximum of 5 times
      retry_wait=10,  # Wait for 10 seconds before retrying a failed task
      must_raise_exceptions=[CustomException],  # Definitely raise CustomException, even if raise_exception is set to False
      create_error_logs=False  # Disable the creation of error logs to optimize scraper performance
  )
  def scrape_heading_task(driver: Driver, data):
    
  ```


  The `bt` utility provides helper functions for:
  - Writing and reading JSON, EXCEL, and CSV files
  - Data cleaning
  Some key functions are:
  - `bt.write_json` and `bt.read_json`: Easily write and read JSON files.
  ```python
  from botasaurus import bt
  data = {"name": "pikachu", "power": 101}
  bt.write_json(data, "output")
  loaded_data = bt.read_json("output")
  ```
  - `bt.write_excel` and `bt.read_excel`: Easily write and read EXCEL files.
  ```python
  from botasaurus import bt
  data = {"name": "pikachu", "power": 101}
  bt.write_excel(data, "output")
  loaded_data = bt.read_excel("output")
  ```
  - `bt.write_csv` and `bt.read_csv`: Easily write and read CSV files.
  ```python
  from botasaurus import bt
  data = {"name": "pikachu", "power": 101}
  bt.write_csv(data, "output")
  loaded_data = bt.read_csv("output")
  ```
  - `bt.write_html` and `bt.read_html`: Write HTML content to a file.
  ```python
  from botasaurus import bt
  html_content = "<html><body><h1>Hello, Mom!</h1></body></html>"
  bt.write_html(html_content, "output")
  ```
  - `bt.write_temp_json`, `bt.write_temp_csv`, `bt.write_temp_html`: Write temporary JSON, CSV, or HTML files for debugging purposes.
  ```python
  from botasaurus import bt
  data = {"name": "pikachu", "power": 101}
  bt.write_temp_json(data)
  bt.write_temp_csv(data)
  bt.write_temp_html("<html><body><h1>Hello, Mom!</h1></body></html>")
  ```
  - Data cleaning functions like `bt.extract_numbers`, `bt.extract_links`, `bt.remove_html_tags`, and more.
  ```python
  text = "The price is $19.99 and the website is https://www.example.com"
  numbers = bt.extract_numbers(text)  # [19.99]
  links = bt.extract_links(text)  # ["https://www.example.com"]
  ```

  The Local Storage utility allows you to store and retrieve key-value pairs, which can be useful for maintaining state between scraper runs.
  Here's how to use it:
  ```python
  from botasaurus.local_storage import LocalStorage
  LocalStorage.set_item("credits_used", 100)
  print(LocalStorage.get_item("credits_used", 0))
  ```

  The `soupify` utility creates a BeautifulSoup object from a Driver, Requests response, Driver Element, or HTML string.
  ```python
  from botasaurus.soupify import soupify
  from botasaurus.request import request, Request
  from botasaurus.browser import browser, Driver
  @request
  def get_heading_from_request(req: Request, data):
     """
     Get the heading of a web page using the request object.
     """
     response = req.get("https://www.example.com")
     soup = soupify(response)
     heading = soup.find("h1").text
     print(f"Page Heading: {heading}")
  @browser
  def get_heading_from_driver(driver: Driver, data):
     """
     Get the heading of a web page using the driver object.
     """
     driver.get("https://www.example.com")
     
     page_soup = soupify(driver)
     page_heading = page_soup.find("h1").text
     print(f"Heading from Driver's Soup: {page_heading}")
     
     body_soup = soupify(driver.select("body"))
     body_heading = body_soup.find("h1").text
     print(f"Heading from Element's Soup: {body_heading}")

  get_heading_from_request()
  get_heading_from_driver()
  ```

  IP Utils provide functions to get information about the current IP address, such as the IP itself, country, ISP, and more:
  ```python
  from botasaurus.ip_utils import IPUtils

  current_ip = IPUtils.get_ip()
  print(current_ip)


  ip_info = IPUtils.get_ip_info()
  print(ip_info)












  ```

  The Cache utility in Botasaurus allows you to manage cached data for your scraper. You can put, get, has, remove, and clear cache data.
  *Basic Usage*
  ```python
  from botasaurus.task import task
  from botasaurus.cache import Cache

  @task
  def scrape_data(data):
      
      return {"processed": data}

  input_data = {"key": "value"}

  Cache.put('scrape_data', input_data, scrape_data(input_data))

  if Cache.has('scrape_data', input_data):
      
      cached_data = Cache.get('scrape_data', input_data)
      print(f"Cached data: {cached_data}")

  Cache.remove('scrape_data', input_data)

  Cache.clear('scrape_data')
  ```
  **Advanced Usage for large-scale scraping projects**
  *Count Cached Items*
  You can count the number of items cached for a particular function, which can serve as a scraping progress bar.
  ```python
  from botasaurus.cache import Cache
  Cache.print_cached_items_count('scraping_function')
  ```
  *Filter Cached/Uncached Items*
  You can filter items that have been cached or not cached for a particular function.
  ```python
  from botasaurus.cache import Cache
  all_items = ['1', '2', '3', '4', '5']

  cached_items = Cache.filter_items_in_cache('scraping_function', all_items)
  print(cached_items)

  uncached_items = Cache.filter_items_not_in_cache('scraping_function', all_items)
  print(uncached_items)
  ```
  *Delete Cache*
  The cache for a function is stored in the `cache/{your_scraping_function_name}/` folder. To delete the cache, simply delete that folder.
  ![delete-cache](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/delete-cache.png)
  *Delete Specific Items*
  You can delete specific items from the cache for a particular function.
  ```python
  from botasaurus.cache import Cache
  all_items = ['1', '2', '3', '4', '5']
  deleted_count = Cache.delete_items('scraping_function', all_items)
  print(f"Deleted {deleted_count} items from the cache.")
  ```
  *Delete Items by Filter*
  In some cases, you may want to delete specific items from the cache based on a condition. For example, if you encounter honeypots (mock HTML served to dupe web scrapers) while scraping a website, you may want to delete those items from the cache.
  ```python
  def should_delete_item(item, result):
      if 'Honeypot Item' in result:
          return True  # Delete the item
      return False  # Don't delete the item
  all_items = ['1', '2', '3', '4', '5']

  Cache.delete_items_by_filter('scraping_function', all_items, should_delete_item)
  ```
  Importantly, be cautious and first use `delete_items_by_filter` on a small set of items which you want to be deleted. Here's an example:
  ```python
  from botasaurus import bt
  from botasaurus.cache import Cache
  def should_delete_item(item, result):
      
      if 'Honeypot Item' in result:
          return True # Delete the item
      return False # Don't delete the item
  test_items = ['1', '2'] # TODO: update with target items
  scraping_function_name = 'scraping_function' # TODO:  update with target scraping function name
  Cache.delete_items_by_filter(scraping_function_name, test_items, should_delete_item)
  for item in test_items:
      if Cache.has(scraping_function_name, item):
          bt.prompt(f"Item {item} was not deleted. Please review the logic of the should_delete_item function.")
  ```

  In web scraping, it is a common use case to scrape product pages, blogs, etc. But before scraping these pages, you need to get the links to these pages.
  Sadly, Many developers unnecessarily increase their work by writing code to visit each page one by one and scrape links, which they could have easily obtained by just looking at the Sitemap.
  The Botasaurus Sitemap Module makes this process easy as cake by allowing you to get all links or sitemaps using:
  - The homepage URL (e.g., `https://www.omkar.cloud/`)
  - A direct sitemap link (e.g., `https://www.omkar.cloud/sitemap.xml`)
  - A `.gz` compressed sitemap
  For example, if you're an Angel Investor seeking innovative tech startups to invest, G2 is an ideal platform to find such startups. You can run the following code to fetch over 160K+ product links from G2:
  ```python
  from botasaurus import bt
  from botasaurus.sitemap import Sitemap, Filters, Extractors
  links = (
      Sitemap("https://www.g2.com/sitemaps/sitemap_index.xml.gz")
      .filter(Filters.first_segment_equals("products"))
      .extract(Extractors.extract_link_upto_second_segment())
      .write_links('g2-products')
  )
  ```
  **Output:**
  ![g2-sitemap-links.png](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/g2-sitemap-links.png)
  Or, let's say you're in the mood for some reading and looking for good stories. The following code will get you over 1000+  from [moralstories26.com](https://moralstories26.com/):
  ```python
  from botasaurus import bt
  from botasaurus.sitemap import Sitemap, Filters
  links = (
      Sitemap("https://moralstories26.com/")
      .filter(
          Filters.has_exactly_1_segment(),
          Filters.first_segment_not_equals(
              ["about", "privacy-policy", "akbar-birbal", "animal", "education", "fables", "facts", "family", "famous-personalities", "folktales", "friendship", "funny", "heartbreaking", "inspirational", "life", "love", "management", "motivational", "mythology", "nature", "quotes", "spiritual", "uncategorized", "zen"]
          ),
      )
      .write_links('moral-stories')
  )
  ```
  **Output:**
  ![moralstories26-sitemap-links.png](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/moralstories26-sitemap-links.png)
  Also, before scraping a site, it's useful to identify the available sitemaps. This can be easily done with the following code:
  ```python
  from botasaurus import bt
  from botasaurus.sitemap import Sitemap
  sitemaps = Sitemap("https://www.omkar.cloud/").write_sitemaps('omkar-sitemaps')
  ```
  **Output:**
  ![omkar-sitemap-links.png](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/omkar-sitemap-links.png)
  To ensure your scrapers run super fast, we cache the Sitemap, but you may want to periodically refresh the cache. To do so, pass the Cache.REFRESH parameter.
  ```python
  from botasaurus import bt
  from botasaurus.sitemap import Sitemap, Filters, Extractors
  from botasaurus.cache import Cache
  links = (
      Sitemap("https://www.g2.com/sitemaps/sitemap_index.xml.gz", cache=Cache.REFRESH) # Refresh the cache
      .filter(Filters.first_segment_equals("products"))
      .extract(Extractors.extract_link_upto_second_segment())
      .write_links('g2-products')
  )
  ```

  Filtering links from a webpage is a common requirement in web scraping. For example, you might want to filter out all non-product pages.
  Botasaurus's `Links` module simplifies link filtering and extraction:
  ```python
  from botasaurus.links import Links, Filters, Extractors

  links = [
      "https://www.g2.com/categories/project-management",
      "https://www.g2.com/categories/payroll",
      "https://www.g2.com/products/jenkins/reviews",
      "https://www.g2.com/products/redis-software/pricing"
  ]

  filtered_links = (
      Links(links)
      .filter(Filters.first_segment_equals("products"))
      .extract(Extractors.extract_link_upto_second_segment())
      .write('g2-products')
  )
  ```

  Sadly, when using caching, most developers write a scraping function that scrapes the HTML and extracts the data from the HTML in the same function, like this:
  ```python
  from botasaurus.request import request, Request
  from botasaurus.soupify import soupify
  @request
  def scrape_data(request: Request, data):
      
      response = request.get(data)
      
      soup = soupify(response)
      
      heading = soup.find('h1').get_text()
      
      return {"heading": heading}
  data_items = [
      "https://www.omkar.cloud/",
      "https://www.omkar.cloud/blog/",
      "https://stackoverflow.com/",
  ]
  scrape_data(data_items)
  ```
  Now, let's say, after 50% of the dataset has been scraped, what if:
  - Your customer wants to add another data point (which is very likely), or
  - One of your BeautifulSoup selectors happens to be flaky and needs to be updated (which is super likely)?
  In such cases, you will have to scrape all the pages again, which is painful as it will take a lot of time and incur high proxy costs.
  To resolve this issue, you can:
  1. Write a function that only scrapes and caches the HTML.
  2. Write a separate function that calls the HTML scraping function, extracts data using BeautifulSoup, and caches the result.
  Here's a practical example:
  ```python
  from bs4 import BeautifulSoup
  from botasaurus.task import task
  from botasaurus.request import request, Request
  from botasaurus.soupify import soupify
  @request(cache=True)
  def scrape_html(request: Request, link):
      
      html = request.get(link).text
      return html
  def extract_data(soup: BeautifulSoup):
      
      heading = soup.find("h1").get_text()
      return {"heading": heading}

  @task(cache=True)
  def scrape_data(link):
      
      html = scrape_html(link)
      
      return extract_data(soupify(html))
  data_items = [
      "https://www.omkar.cloud/",
      "https://www.omkar.cloud/blog/",
      "https://stackoverflow.com/",
  ]
  scrape_data(data_items)
  ```
  With this approach:
  - If you need to add data points or fix BeautifulSoup bugs, delete the `cache/scrape_data` folder and re-run the scraper.
  ![delete-cache](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/delete-cache.png)
  - You only need to re-run the BeautifulSoup extraction, not the entire HTML scraping, saving time and proxy costs. Yahoo!
  **PRO TIP**: This approach also makes your `extract_data` code easier and faster to test, like this:
  ```python
  from bs4 import BeautifulSoup
  from botasaurus import bt
  def extract_data(soup: BeautifulSoup):
      heading = soup.find('h1').get_text()
      return {"heading": heading}
  if __name__ == '__main__':
      
      bt.write_temp_json(scrape_data("https://www.omkar.cloud/", cache=False))
  ```

  For websites with minimal protection, use the `Request` module.
  Here's a template for creating production-ready datasets using the `Request` module:
  ```python
  from bs4 import BeautifulSoup
  from botasaurus.task import task
  from botasaurus.request import request, Request,NotFoundException
  from botasaurus.soupify import soupify
  @request(
      
      cache=True,
      max_retry=20, # Retry up to 20 times, which is a good default
      output=None,
      close_on_crash=True,
      raise_exception=True,
      create_error_logs=False,
  )
  def scrape_html(request: Request, link):
      
      response = request.get(link)
      if response.status_code == 404:
          
          raise NotFoundException(link)
      response.raise_for_status()
      return response.text
  def extract_data(soup: BeautifulSoup):
      
      heading = soup.find("h1").get_text()
      return {"heading": heading}

  @task(
      cache=True,
      close_on_crash=True,
      create_error_logs=False,
      parallel=40, # Run 40 requests in parallel, which is a good default
  )
  def scrape_data(link):
      
      html = scrape_html(link)
      
      return extract_data(soupify(html))
  data_items = [
      "https://www.omkar.cloud/",
      "https://www.omkar.cloud/blog/",
      "https://stackoverflow.com/",
  ]
  scrape_data(data_items)
  ```
  For visiting well protected websites, use the `Browser` module.
  Here's a template for creating production-ready datasets using the `Browser` module:
  ```python
  from bs4 import BeautifulSoup
  from botasaurus.task import task
  from botasaurus.browser import browser, Driver, NotFoundException
  from botasaurus.soupify import soupify
  @browser(
      
      
      
      cache=True,
      max_retry=5,  # Retry up to 5 times, which is a good default
      reuse_driver= True, # Reuse the same driver for all tasks
      output=None,
      close_on_crash=True,
      raise_exception=True,
      create_error_logs=False,
  )
  def scrape_html(driver: Driver, link):
      
      if driver.config.is_new:
          driver.google_get(
              link,
              bypass_cloudflare=True,  # delete this line if the website you're accessing is not protected by Cloudflare
          )
      response = driver.requests.get(link)
      if response.status_code == 404:
          
          raise NotFoundException(link)
      response.raise_for_status()
      html = response.text
      return html
  def extract_data(soup: BeautifulSoup):
      
      heading = soup.select_one('.product-head__title [itemprop="name"]').get_text()
      return {"heading": heading}

  @task(
      cache=True,
      close_on_crash=True,
      create_error_logs=False,
  )
  def scrape_data(link):
      
      html = scrape_html(link)
      
      return extract_data(soupify(html))
  data_items = [
      "https://www.g2.com/products/stack-overflow-for-teams/reviews?page=8",
      "https://www.g2.com/products/jenkins/reviews?page=19",
  ]
  scrape_data(data_items)
  ```

  - Use `google_get`, use `google_get`, and use `google_get`!
  - Don't use `headless` mode, else you will surely be identified by Cloudflare, Datadome, Imperva.
  - Don't use Proxies, instead use your home Wi-Fi connection, even when scraping hundreds of thousands of pages.

  While developing a scraper, multiple browser instances may remain open in the background (because of interrupting it with CTRL + C). This situation can cause your computer to hang.
  ![Many Chrome processes running in Task Manager](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/chrome-running.png)
  To prevent your PC from hanging, you can run the following command to close all Chrome instances:
  ```shell
  python -m close_chrome
  ```

  To run a Scraper in Docker, use the Botasaurus Starter Template, which includes the necessary Dockerfile and Docker Compose configurations.
  Use the following commands to clone the Botasaurus Starter Template, build a Docker image from it, and execute the scraper within a Docker environment.
  ```
  git clone https://github.com/omkarcloud/botasaurus-starter my-botasaurus-project
  cd my-botasaurus-project
  docker-compose build
  docker-compose up
  ```

  Running a scraper in Gitpod offers several benefits:
  - Allows your scraper to use a powerful 8-core machine with 1000 Mbps internet speed
  - Makes it easy to showcase your scraper to customers without them having to install anything, by simply sharing the Gitpod machine link
  In this example, we will run the Botasaurus Starter template in Gitpod:
  1. First, visit [this link](https://gitpod.io/#https://github.com/omkarcloud/botasaurus-starter) and sign up using your GitHub account.
     ![Screenshot (148)](https://raw.githubusercontent.com/omkarcloud/google-maps-scraper/master/screenshots/open-in-gitpod.png)
  2. Once signed up, open the starter project in Gitpod.
     ![gp-continue](https://raw.githubusercontent.com/omkarcloud/assets/master/images/gitpod-continue.png)
  3. In the terminal, run the following command:
     ```bash
     python run.py
     ```
  4. You will see a popup notification with the heading "A service is available on port 3000". In the popup notification, click the **"Open Browser"** button to open the UI Dashboard in your browser
     ![open-browser.png](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/open-browser.png)
  5. Now, you can press the `Run` button to get the results.
     ![starter-photo.png](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/starter-photo.png)
  Note: Gitpod is not suitable for long-running tasks, as the environment will automatically shut down after a short period of inactivity. Use your local machine or a cloud VM for long-running scrapers.

  To run your scraper in a Virtual Machine, we will:
  - Create a static IP
  - Create a VM with that IP
  - SSH into the VM
  - Install the scraper
  Now, follow these steps to run your scraper in a Virtual Machine:
  1. 1. If you don't already have one, create a Google Cloud Account. You'll receive a $300 credit to use over 3 months.
     ![Select-your-billing-country](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/Select-your-billing-country.png)
  2. Visit the [Google Cloud Console](https://console.cloud.google.com/welcome?cloudshell=true) and click the Cloud Shell button. A terminal will open up.
     ![click-cloud-shell-btn](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/click-cloud-shell-btn.png)
  3. Run the following commands in the terminal:
     ```bash
     python -m pip install bota
     python -m bota create-ip
     ```
     You will be asked for a VM name. Enter any name you like, such as "pikachu".
     > Name: pikachu
     Then, you will be asked for the region for the scraper. Press Enter to go with the default, which is "us-central1", as most global companies host their websites in the US.
     > Region: Default
     ![Install bota](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/install-bota.gif)
  4. Now, visit [this link](https://console.cloud.google.com/marketplace/product/click-to-deploy-images/nodejs) and create a deployment from Google Click to Deploy with the following settings:
     ```
     zone: us-central1-a # Use the zone from the region you selected in the previous step.
     Series: N1
     Machine Type: n1-standard-2 (2 vCPU, 1 core, 7.5 GB memory)
     Network Interface [External IP]: pikachu-ip # Use the IP name you created in the previous step.
     ```
     ![deploy-node](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/deploy-node.gif)
  5. Visit [this link](https://console.cloud.google.com/compute/instances) and click the SSH button to SSH into the VM.
     ![ssh-vm](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/ssh-vm.png)
  6. Now, run the following commands in the terminal, then wait for 5 minutes for the installation to complete:
     ```bash
     curl -sL https://raw.githubusercontent.com/omkarcloud/botasaurus/master/vm-scripts/install-scraper.sh | bash -s -- https://github.com/omkarcloud/botasaurus-starter
     ```
     ![install-scraper](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/install-scraper.gif)
     Note: If you are using a different repo, replace `https://github.com/omkarcloud/botasaurus-starter` with your repo URL.
  That's it! You have successfully launched the Scraper in a Virtual Machine. When the previous commands are done, you will see a link to your scraper. Visit it to run your scraper.
  ![vm-success](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/vm-success.gif)

  If you are deleting a custom scraper you deployed, please ensure you have downloaded the results from it.
  Next, follow these steps to delete the scraper:
  1. Delete the static IP by running the following command:
     ```bash
     python -m bota delete-ip
     ```
     You will be asked for the name of the VM you created in the first step. Enter the name and press Enter.
     ![Delete IP](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/delete-ip.png)
     Note: If you forgot the name of the IP, you can also delete all the IPs by running `python -m bota delete-all-ips`.
  2. Go to [Deployment Manager](https://console.cloud.google.com/dm/deployments) and delete your deployment.
     ![Delete deployment](https://raw.githubusercontent.com/omkarcloud/botasaurus/master/images/delete-deployment.gif)
  That's it! You have successfully deleted the scraper, and you will not incur any furthur charges.

  Visit [this link](https://github.com/omkarcloud/botasaurus/blob/master/run-scraper-in-kubernetes.md) to learn how to run scraper at scale using Kubernetes.

  We'd love hear it! Share them on [GitHub Discussions](https://github.com/omkarcloud/botasaurus/discussions).
  [![Make](https://raw.githubusercontent.com/omkarcloud/google-maps-scraper/master/screenshots/ask-on-github.png)](https://www.omkar.cloud/l/botasaurus-make-discussions/)
  <!--

  Yes, we have a Discord community where you can connect with other developers, ask questions, and share your experiences. Join our Discord community [here](https://discord.com/invite/rw9VeyuSM8). -->

  Congratulations on completing the Botasaurus Documentation! Now, you have all the knowledge needed to effectively use Botasaurus.
  You may choose to read the following questions based on your interests:
  1. [How to Run Botasaurus in Google Colab?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-to-run-botasaurus-in-google-colab)
  2. [How can I allow users to filter the scraped data?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-can-i-allow-users-to-filter-the-scraped-data)
  3. [How can I allow the user to sort the scraped data?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-can-i-allow-the-user-to-sort-the-scraped-data)
  4. [How can I present the scraped data in different views?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-can-i-present-the-scraped-data-in-different-views)
  5. [When building a large dataset, customers often request data in different formats like overview and review. How can I do that?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#when-building-a-large-dataset-customers-often-request-data-in-different-formats-like-overview-and-review-how-can-i-do-that)
  6. [What more can I configure when adding a scraper?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#what-more-can-i-configure-when-adding-a-scraper)
  7. [How to control the maximum number of browsers and requests running at any point of time?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-to-control-the-maximum-number-of-browsers-and-requests-running-at-any-point-of-time)
  8. [How do I change the title, header title, and description of the scraper?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-do-i-change-the-title-header-title-and-description-of-the-scraper)
  9. [How can I use a database like PostgreSQL with UI Scraper?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-can-i-use-a-database-like-postgresql-with-ui-scraper)
  10. [Which PostgreSQL provider should I choose among Supabase, Google Cloud SQL, Heroku, and Amazon RDS?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#which-postgresql-provider-should-i-choose-among-supabase-google-cloud-sql-heroku-and-amazon-rds)
  11. [How to create a PostgreSQL database on Supabase?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-to-create-a-postgresql-database-on-supabase)
  12. [How to create a PostgreSQL database on Google Cloud?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#how-to-create-a-postgresql-database-on-google-cloud)
  13. [I am a Youtuber, Should I create YouTube videos about Botasaurus? If so, how can you help me?](https://github.com/omkarcloud/botasaurus/blob/master/advanced.md#i-am-a-youtuber-should-i-create-youtube-videos-about-botasaurus-if-so-how-can-you-help-me)

  - To That, who has given me a sufficiently intelligent mind to create Botasaurus and do a lot of good.
  <!-- - To the One who has given me with a sufficiently intelligent, practical mind with a will to do good, which led to the creation of Botasaurus. This, I believe, is the #1 gift a human can receive. It helps both here and here after. If you possess such a gift, please cherish it, for very very and very few people in this age have it. -->
  - I made Botasaurus because I would be really happy if you could use it to successfully complete your project. So, a Gigantic Thank you for using Botasaurus!
  - Kudos to the Apify Team for creating the `proxy-chain` library. The implementation of SSL-based Proxy Authentication wouldn't have been possible without their groundbreaking work on `proxy-chain`.
  - Shout out to [ultrafunkamsterdam](https://github.com/ultrafunkamsterdam) for creating `nodriver`, which inspired the creation of Botasaurus Driver.
  - A big thank you to [daijro](https://github.com/daijro) for creating [hrequest](https://github.com/daijro/hrequests), which inspired the creation of botasaurus-requests.
  - A humongous thank you to Cloudflare, DataDome, Imperva, and all bot recognition systems. Had you not been there, we wouldn't be either 😅.
  *Now, what are you waiting for? 🤔 Go and make something mastastic! 🚀*
  <!--

  If you're tackling a challenging web scraping project and seek guidance from an expert web scraper who himself has done many tough projects, I can provide you with an effective plan that will significantly reduce your project implementation time. You can book a planning call with me for $240/hr [here](https://www.omkar.cloud/consultation/).
  If you're not satisfied with the plan, you can request a full refund within 30 days. I will send the refund via PayPal within 24 hours of receiving your request. -->

  Become one of our amazing stargazers by giving us a star ⭐ on GitHub!
  It's just one click, but it means the world to me.
  <a href="https://github.com/omkarcloud/botasaurus/stargazers">
      <img src="https://bytecrank.com/nastyox/reporoster/php/stargazersSVG.php?user=omkarcloud&repo=botasaurus" alt="Stargazers for @omkarcloud/botasaurus">
  </a>

  > By using Botasaurus, you agree to comply with all applicable local and international laws related to data scraping, copyright, and privacy. The developers of Botasaurus are not responsible for any misuse of this software. It is the sole responsibility of the user to ensure adherence to all relevant laws regarding data scraping, copyright, and privacy, and to use Botasaurus in an ethical and legal manner.
  We take the concerns of the Botasaurus Project very seriously. For any inquiries or issues, please contact Chetan Jain at [chetan@omkar.cloud](mailto:chetan@omkar.cloud). We will take prompt and necessary action in response to your emails.


