# packages

pkgId: bbe7b77b39394fc5b5a6874dc0521427536644771e485aa07c924504d3c470bf
name: python-Avalara
arch: src
version: 24.10.0
epoch: 0
release: 1
summary: Avalara Tax Python SDK.
url: https://github.com/avadev/AvaTax-REST-V2-Python-SDK
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Avalara-24.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/avadev/AvaTax-REST-V2-Python-SDK.svg?branch=master)](https://travis-ci.org/avadev/AvaTax-REST-V2-Python-SDK)
  [![PyPI](https://img.shields.io/pypi/v/Avalara.svg)](https://pypi.python.org/pypi/Avalara)

  This GitHub repository is the Python SDK for Avalara's world-class tax service, AvaTax.  It uses the AvaTax REST v2 API, which is a fully REST implementation and provides a single client for all AvaTax functionality.  For more information about AvaTax REST v2, please visit [Avalara's Developer Network](http://developer.avalara.com/) or view the [online Swagger documentation](https://sandbox-rest.avatax.com/swagger/ui/index.html).




  Install simply with pip.
  ```pip install Avalara```

  **OR**

  1. Clone this repository to your local machine.
  ```
  $ git clone https://github.com/avadev/AvaTax-REST-V2-Python-SDK.git
  ```
  2. Once downloaded, cd into the ```AvaTax-REST-V2-Python-SDK``` directory.
  ```
  $ cd AvaTax-REST-V2-Python-SDK
  ```
  3. Begin a new virtual environment with Python 3 and activate it.
  ```
  AvaTax-REST-V2-Python-SDK $ python3 -m venv ENV
  AvaTax-REST-V2-Python-SDK $ source ENV/bin/activate
  ```
  4. [pip](https://pip.pypa.io/en/stable) install this package as well as the testing set of extras into your virtual enviroment.
  ```
  (ENV) AvaTax-REST-V2-Python-SDK $ pip install -e .
  (ENV) AvaTax-REST-V2-Python-SDK $ pip install -e .[testing]
  ```






  **Import the AvataxClient from the avalara module**

  First thing to do is to import the AvataxClient constructor module to your name space, or your python script.

  ```
  from avalara import AvataxClient
  ```

  **Now we are ready to construct a client object**

  Create a new AvaTaxClient object:
  ```
      client = AvataxClient('my test app',
                            'ver 0.0',
                            'my test machine',
                            'sandbox')
  ```
  The client constructor takes four string parameters, in squence they are `app_name(required)`, `app_version(required)`, `machine_name(optional)`, and `environment(required)`.
  The app_name, app_version, machine_name will be used to construct the [Client Header](https://developer.avalara.com/avatax/client-headers/) associated with each call made by this client. It will be returned within the response object to help you keep track of the API calls.
  The `environment` variable can be either `"sandbox"` or `production`, they correspond to the two different environments for AvaTax service.
  If you are a regular or free trial customer please use `"production"`. If you don't have an account, you can sign up for a free trail account on our [developer site](https://developer.avalara.com/avatax/signup/), this will be a production account as well.
  If you wish to obtain a Sandbox account, please contact your [Customer Account Manager](https://help.avalara.com/Frequently_Asked_Questions/Avalara_AvaTax_FAQ/How_do_I_get_access_to_our_development%2F%2Fsandbox_account%3F)


  **Ping the service**

  Now we have a client object, we can ping the AvaTax REST V2 server to ensure connectivity.
  ```
    response = client.ping()

    
    print(response.text())

    
    print(response.json())

    
    print(response.status_code())

    
    print(response.raw())
  ```
  Note that the response from all REST calls made using this SDK will be [Request](http://docs.python-requests.org/en/master/user/quickstart/#response-content) object, which contains status code, response text, raw josn, and more information on the respnse.


  **Add credentials to your client object**

  Unlike `ping`, most methods in our REST V2 API requires you to be authenticated in order to associate those information provided by you with your account.
  To find out if a method requires authentication, visit our [API Reference](https://developer.avalara.com/api-reference/avatax/rest/v2/methods/Transactions/) page.
  To add credential on the current client object:
  ```
    client = client.add_credentials('USERNAME/ACCOUNT_ID', 'PASSWORD/LICENSE_KEY')
  ```
  The `add_credential` method will hash your username/password, or account_id/license_key pair and attach to every call made by your client object, meaning you only have to add credential once to each client you prepare to use.

  To verify that you have added a valid credential, simply call the `ping` method again, this time in the response text you should see `"authenticated": true`.


  **To create a transaction using your client object**

  Now our client object is authenticated, we can call the create_transaction method which calls the [CreateTransaction API](https://developer.avalara.com/api-reference/avatax/rest/v2/methods/Transactions/CreateTransaction/)
  ```
    transaction_response = client.create_transaction(tax_document)
    print(transaction_response.text())

    tax_document = {
        'addresses': {'SingleLocation': {'city': 'Irvine',
                                         'country': 'US',
                                         'line1': '123 Main Street',
                                         'postalCode': '92615',
                                         'region': 'CA'}},
        'commit': False,
        'companyCode': 'DEFAULT',
        'currencyCode': 'USD',
        'customerCode': 'ABC',
        'date': '2017-04-12',
        'description': 'Yarn',
        'lines': [{'amount': 100,
                  'description': 'Yarn',
                   'itemCode': 'Y0001',
                   'number': '1',
                   'quantity': 1,
                   'taxCode': 'PS081282'}],
        'purchaseOrderNo': '2017-04-12-001',
        'type': 'SalesInvoice'}

  ```
  The create_transaction method takes in a model, in python it's a dictionary type object. Which you will fill out to include all of your transaction information. In this case, we are using the [TransactionModel](https://developer.avalara.com/api-reference/avatax/rest/v2/models/TransactionModel/)
  For information on other models use by AvaTax APIs, visit our information page [here](https://developer.avalara.com/api-reference/avatax/rest/v2/models)




  Like our SDKs in other languages, the Python SDK includes all methods offered by the AvaTax REST V2 API. To find a mehtod corresponding to a specific API endpoint, simply visit this [code page](https://github.com/avadev/AvaTax-REST-V2-Python-SDK/blob/master/src/client_methods.py)
  To learn more about integrating our REST API into your system, visit our [developer guide](https://developer.avalara.com/avatax/dev-guide/getting-started-with-avatax/) that contains information on using the powerful features offered by our API.




  We realize that having to format the TransactionModel can be complicated and time consuming, thus we created a tool called Transaction Builder to help you put together a transaction model, and create it!
  First import the transaction builder constructor into your name space:
  ```from avalara.transaction_builder import TransactionBuilder```

  Then, let's create a transaction builder object:
  ```
    tb = TransactionBuilder(client, "DEFAULT", "SalesInvoice", "ABC")
  ```
  The builder takes four required parameters, in sequence they are
  - The client object
  - Company name(created through AvaTax portal or by calling [CreateCompany API](https://developer.avalara.com/api-reference/avatax/rest/v2/methods/Companies/CreateCompanies/))
  - The type of transaction, a [full list](https://developer.avalara.com/api-reference/avatax/rest/v2/models/enums/DocumentType/) of options.
  - The customer code, an unique code identifying the customer that requested this transaction.

  Now you are free to add transaction details to this object, by using methods like `with_address`, `with_line`, `with_parameter`.
  For a fulll list of transaction builder methods available and the parameters they take in, visit the [code page](https://github.com/avadev/AvaTax-REST-V2-Python-SDK/blob/master/src/transaction_builder_methods.py)
  In the end, you may call the `create` method on your builder object, which will call the CreateTransaction API with the transaction model you have build so far, and return back the response.




  If you wish to run the integration and unit testings, you must store a pair of credentials in the current enviroment.
  Add the following to the ```activate``` file in your environment, and restart bash.
  OR simply ```export``` them directly:

  ```
  export SANDBOX_USERNAME='your_sandbox_username'
  export SANDBOX_PASSWORD='your_sandbox_password'


  SANDBOX_ACCOUNTID='your_sandbox_account_id'
  SANDBOX_LICENSEKEY='your_sandbox_license_key'
  ```
  Note: Only *Sandbox credentials* should be used for testing, as the test case will commit/adjust/void dummy transactions on the account to verify functionalities.



  Logging is implemented using standard Python logging framework.

  1. All relevant methods from `AvataxClient` class are decorated with `ava_log` decorator.(This is achieved using another decorator at class level, `decorate_all_methods`)
  2. `ava_log` decorator collects relevant request data, response data useful for instrumentation and logs error data in case of exception.
  3. `AvataxClient` constructor is modified with optional parameter, `is_log_req_resp_allowed` (defaulted to False), to control if log entry should contain request and response objects.
  4. SDK Consumer code can also set logger property of `AvataxClient` to use already configured logger instance. e.g.
  ```
  from logging import config



  config.fileConfig("logger_config.conf")

  logger = logging.getLogger()


  client.logger = logger
  ```




  User feedbacks are highly valued here at Avalara, we want to ensure the best experience for every customer using our services. If you have any concern with this SDK or AvaTax in general, please post your queston/suggestion on our [Developer Relation Forum](https://community.avalara.com/avalara/category_sets/developers) as we will reply to you in a timely manner.
  If you wish to contribute to this SDK, please fork the [repository](https://github.com/avadev/AvaTax-REST-V2-Python-SDK) and submit your pull request from the forked version. We are happy to review your contribution, and merge them if all checks has passed!




  [Han Bao](https://www.linkedin.com/in/hbao2016)

  [Philip Werner](https://www.linkedin.com/in/philip-werner-421aa66a)

  [Robert Bronson](https://www.linkedin.com/in/robert-bronson)

  [Adrienne Karnoski](https://www.linkedin.com/in/adrienne-karnoski)


pkgId: 797640f1e4a7142d6fde7d01aa24a23bfe7717bd39b029d5951504543f59072b
name: python-Avena
arch: src
version: 1.7
epoch: 0
release: 1
summary: Avena is an image processing library and command-line tool.
url: https://bitbucket.org/eliteraspberries/avena
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Avena-1.7-1.src.rpm
checksum_type: sha256
description:
  Avena requires:
  -  `Python <https://www.python.org/>`__ (version 2 or 3);
  -  the `Python Imaging
     Library <http://pythonware.com/products/pil/>`__ (PIL) or
     `Pillow <http://python-pillow.github.io/>`__;
  -  `NumPy <http://www.numpy.org/>`__;
  -  `pyglet <https://bitbucket.org/pyglet/pyglet>`__;
  -  and `docopt <http://docopt.org/>`__.
  Install Avena with `pip <https://pip.pypa.io/en/stable/>`__:
      pip install avena


pkgId: 4b491547c803e120cda7581a86fec1d10bc098de31b00e3471233a14349fc436
name: python-AveyTense
arch: src
version: 0.3.30
epoch: 0
release: 1
summary: Library written in Python, includes several extensions for inbuilt Python solutions
url: https://aveyzan.glitch.me/tense/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AveyTense-0.3.30-1.src.rpm
checksum_type: sha256
description:
      It is highly recommended to continuously switch to the latest versions once they are out.
      I documented most of declarations in the files included in this project, and whenever there
      is need in seeing, what changed, there is text file ``./tense/information/changes.txt``, in an
      archive you normally download on `this page <https://aveyzan.glitch.me/tense>`_, but later only text file
      may be downloaded, since I learned, how to update this project on PyPI.

      To begin, do ``pip install AveyTense`` (assuming you have Python 3.9 or greater; if you *don't*
      have recent version, visit this page and specify the version, like ``pip install AveyTense==0.3.29``).
      Last thing is creating a new Python file and writing following ``import`` statement:
      ::

          from tense import * # or "import tense as ts", no matter which way you prefer


      .. note:: If there is no ``discord`` or ``typing_extensions`` module, code of Tense will install them
          both automatically after compilation attempt.

      Enjoy!


      Features:

      - the ``Color`` class for colorizing output text on the console
      - the ``Abstract`` class (equivalent to ``abc.ABCMeta`` metaclass) for creating non-instantiable classes
      - the ``Final`` class (equivalent to ``typing.final()`` decorator) for creating non-inheritable classes
      - the ``Frozen`` class (equivalent to ``dataclasses.dataclass(frozen = True)``) for creating immutable objects
      - the ``abroad()`` function being more developed version of inbuilt function ``range()``
      - the ``reckon()`` function being more developed version of inbuilt function ``len()``
      - the ``ChangeVar`` class for creating sentinels inside ``while`` loops
      - the ``FinalVar`` class for creating final variables (referring to ``typing.Final``)
      - the ``Tense`` class featuring methods extending possibilities of ``abroad()`` function, math methods, time methods,
          and methods for tossing up (randomizing) results


pkgId: 3ee3249fd73b1857e34845dfb10386bc4e82361086cce99a1b0a5a3fb371708b
name: python-AveyTense
arch: src
version: 0.3.31
epoch: 0
release: 1
summary: Library written in Python, includes several extensions for inbuilt Python solutions
url: https://aveyzan.glitch.me/tense/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AveyTense-0.3.31-1.src.rpm
checksum_type: sha256
description:
  **AveyTense** (formally *Tense*) is a library written by Aveyzan using Python, which provides especially extensions to inbuilt Python solutions.




  - the `abroad()` function being extended version of `range()` inbuilt Python function
  - the `reckon()` function being extended version of `len()` inbuilt Python function
  - the `Math` class featuring same and more math methods than `math` inbuilt Python module
  - the `Time` class featuring several time management methods using `datetime` inbuilt Python module
  - the `Tense` class featuring all methods from `Math` and `Time`, as well as `probability()` class method,
    methods for disassembling code, randomizing results, personalized `print()` and `input()` inbuilt functions
    implementations, methods for checking and converting
  - the `Color` class, which colorizes the output and features several font decorations as in ANSI, and supports
    `RGB` and `CMYK` class instances



  - the `tense.constants` submodule featuring some math constants, as well as some from gaming and Tense versions
  - the `tense.fencord` submodule featuring several Discord.py solutions
  - the `tense.games` submodule featuring class `Games`, which has some Tic-Tac-Toe methods and `mcEnchBook()` for
    generating Minecraft `/give enchanted_book` commands
  - the `tense.operators` submodule being extension of `operator` inbuilt Python module
  - the `tense.types_collection` submodule, which contains utility types from `typing`, `enum`, `types`, `inspect`,
    `subprocess` inbuilt Python modules, and from `typing_extensions` PyPi project



  To install AveyTense, you only need to have Python 3.9 or above, and run the following command:

  ```
  pip install AveyTense
  ```

  If you are out-of-date, consider checking out [releases section](https://pypi.org/project/AveyTense/#history), then
  use this command in the following way: `pip install AveyTense==<version>`, like `pip install AveyTense==0.3.31`.

  > [!NOTE]
  > It is highly recommended to install latest final version of AveyTense. Do not rely on alpha, beta releases, and
  > release candidates before their final counterparts are published.

  > [!WARNING]
  > Since AveyTense 0.3.30, archive files will no longer be available on [this page](https://aveyzan.glitch.me/tense),
  > due to expiry of formula after orienting publication of next versions to PyPi. Instead of providing change log via file
  > `./tense/information/changes.txt` normally included in zip/7-zip files, changes will be now provided in [this Google document](https://docs.google.com/document/d/1GC_KAOXML65jNfBZA8GhVViqPnrMoFtbLv_jHvUhBlg/edit?usp=sharing).


pkgId: 37c8376fe87431798346b468a3001838c5d43e3d43db95f50f2e50849222c7d4
name: python-AviPy
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: A package containing useful tools for aviation related code
url: https://github.com/pcs03/AviPy
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AviPy-0.3.3-1.src.rpm
checksum_type: sha256
description:
  AviPy is a Python package specifically developed for the purposes of the Flight Operations Engineering (FOE) course at the HvA. For the purposes of the FOE assignments, many pieces of code can be shared between projects. That is what motivated the creation of a Python package, that can be used as a common repository for code snippets useful for the projects.


  - [Features](#features)
  - [Where to get it](#where-to-get-it)
  - [Installation](#installation)
  - [Documentation](#documentation)
  - [License](#license)


  The AviPy package includes many classes and functions useful for FOE projects. These are the main features of AviPy:
  - The qty module contains classes for every SI-Unit used in aviation-related calculations. One can declare a variable with a distance unit like this: `height = qty.Distance.Ft(5000)`, what the Distance class does under the hood, is that the value in ft is converted to a value in meters. When the user wants to retrieve the value in any unit, on can do this `height.ft`, which will return the value in feet.
  - The geo module contains the Coord class, which is a wrapper for a pair of latitude and longitude values. The class comes with many useful functions related to coordinates.
  - The constants module contains commonly used constants in the field of aviation.
  - The atmosphere module contains many useful functions related to earth's atmosphere.


  To obtain the code, so you can use it for yourself, clone the repository to your system:
  ```bash
  git clone https://github.com/pcs03/AviPy.git
  ```


  To install the package to your system, so you can import the module in your own project, AviPy can be installed using pip:
  ```bash
  pip install path/to/avipy
  ```
  This command will install the package to your local system. If you have a virtual environment activated while executing the command, the package will be installed to your virtual environment.


  [Docs](https://github.com/pcs03/AviPy/tree/main/docs)


  [GNU General Public License V3.0](https://github.com/pcs03/AviPy/blob/main/LICENSE)


pkgId: e770d1c2b7e355affb6137fd9ba51418591ee68e9e09249f0d3f06b33f531b83
name: python-Awesome-mixins
arch: src
version: 0.18
epoch: 0
release: 1
summary: Set of the mixins for class based view on django.
url: https://github.com/MrLucasCardoso/awesome_mixins
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Awesome-mixins-0.18-1.src.rpm
checksum_type: sha256
description:
  ![](https://mrlucascardoso.github.io/awesome-mixins-docs/images/logo.png)


  Set of the mixins for class based view on django.

  Coming soon... [DOCS](https://mrlucascardoso.github.io/awesome-mixins-docs/) <- Take a look :sweat_smile:

  At the moment us only have ListMixin available :disappointed_relieved:, but I'm arranging to improve and add new functions to the project.

  ![](https://media.tenor.co/images/64d26d582e2e5aedf9ce035c63e1f1d9/tenor.gif)

  Feel free to contribute :thumbsup:


pkgId: 7760b157444d3c3cf60fb15fa14c8c574b90bac0158d0b95f5aeb162abd70a44
name: python-AwesomeTkinter
arch: src
version: 2021.11.8
epoch: 0
release: 1
summary: Pretty tkinter widgets
url: https://github.com/Aboghazala/AwesomeTkinter
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AwesomeTkinter-2021.11.8-1.src.rpm
checksum_type: sha256
description:
  - [FireDM](https://github.com/firedm/FireDM)
  ![FireDM](https://user-images.githubusercontent.com/58998813/112715559-83852f80-8ee9-11eb-8ea3-d8c0f98a0153.png)

  `python pip install awesometkinter` on windows
  `python3 pip install awesometkinter` on linux
  for quick test:
  ```
  import awesometkinter as atk
  atk.main()
  ```
  or from terminal:
  ```
  python3 -m awesometkinter
  or just
  awesometkinter
  ```
  this will display a test window

  - minimum python version 3.6
  - tkinter
  - pillow >= 6.0.0
  - python-bidi (for linux)

  - some widgets don't work well with all tkinter themes, it is recommended to
    set tkinter theme to 'default', 'alt', or 'classic' for things to
    work fine, so after creating your root you should change
    theme like example below

  ```
  import tkinter as tk
  from tkinter import ttk
  import awesometkinter as atk

  root = tk.Tk()
  root.config(background=atk.DEFAULT_COLOR)


  s = ttk.Style()
  s.theme_use('default')

  f1 = atk.Frame3d(root)
  f1.pack(side='left', expand=True, fill='both', padx=3, pady=3)

  bar = atk.RadialProgressbar3d(f1, fg='cyan', size=120)
  bar.pack(padx=20, pady=20)
  bar.start()

  atk.Button3d(f1, text='3D Button').pack(pady=10)
  f2 = atk.Frame3d(root)
  f2.pack(side='left', expand=True, fill='both', padx=3, pady=3)

  bar = atk.RadialProgressbar(f2, fg='green')
  bar.pack(padx=30, pady=30)
  bar.start()
  atk.Button3d(f2, text='Button2').pack(pady=10)
  root.mainloop()
  ```

  you can enable tooltip for tkinter widgets on mouse hover, signature and arguments like below
  ```python
  class ToolTip:
      def __init__(self, widget, text, waittime=500, xoffset=10, yoffset=10, **kwargs):
          """
          tooltip class
          Args:
              widget: any tkinter widget
              text: tooltip text
              waittime: time in milliseconds to wait before showing tooltip
              xoffset(int): x - offset (pixels) of tooltip box from mouse pointer
              yoffset(int): y - offset (pixels) of tooltip box from mouse pointer
              kwargs: parameters to be passed to tooltip label, e.g: , background='red', foreground='blue', etc
          """
  ```
  Tooltip Example:
  ```python
  import tkinter as tk
  import awesometkinter as atk
  root = tk.Tk()
  btn = tk.Button(root, text="Hello", command=root.destroy)
  btn.pack()
  lbl = tk.Label(root, text='my label')
  lbl.pack()
  btn.tp = tooltip(btn, "Hello world")
  lbl.tp = tooltip(lbl, "Hello world")

  btn.tp.waittime = 100
  btn.tp.text = 'new text'

  lbl.counter = 0
  def foo():
      
      lbl.counter = lbl.counter + 1 if lbl.counter < 100 else 0
      lbl.tp.update_tooltip('Progress: ' + str(lbl.counter) + '%')  # or use lbl.tp.text='some text'
      root.after(1000, foo)
  foo()
  root.mainloop()
  ```
  also, you can use a lot of useful functions that manipulate images, e.g.
  to create a tkinter PhotoImage from a file but want to change its size
  and color:
  ```
  img = atk.create_image(fp='path to my image file', color='red', size=(150, 100))
  ```


pkgId: 47c0642f29ce46e8a6941efc0b2a700d275d024bb00300e4a582bc5b19d74515
name: python-AyugeSpiderTools
arch: src
version: 3.10.1
epoch: 0
release: 1
summary: scrapy 扩展库：用于扩展 Scrapy 功能来解放双手。
url: https://www.ayuge.top/mkdocs-material/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AyugeSpiderTools-3.10.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://ayugespidertools.readthedocs.io" target="_blank" rel="noopener noreferrer">
          <img src="https://raw.githubusercontent.com/shengchenyang/AyugeSpiderTools/master/artwork/ayugespidertools-logo.png" alt="ayugespidertools-logo">
      </a>
  </p>
  <hr/>



  ![license](https://img.shields.io/github/license/shengchenyang/AyugeSpiderTools)
  ![python support](https://img.shields.io/badge/python-3.8%2B-blue)
  ![GitHub Workflow Status (with branch)](https://img.shields.io/github/actions/workflow/status/shengchenyang/AyugeSpiderTools/codeql.yml?branch=main)
  ![Read the Docs](https://img.shields.io/readthedocs/ayugespidertools)
  ![GitHub all releases](https://img.shields.io/github/downloads/shengchenyang/AyugeSpiderTools/total?label=releases%20downloads)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/AyugeSpiderTools?label=pypi%20downloads)
  ![codecov](https://codecov.io/gh/shengchenyang/AyugeSpiderTools/graph/badge.svg?token=1QLOEW2NTI)

  **简体中文** | [English](https://github.com/shengchenyang/AyugeSpiderTools/blob/master/README_en.md)



  > 一句话介绍：用于扩展 Scrapy 功能来解放双手。

  在使用 `Scrapy` 开发爬虫时，免不了会重复地编写 `settings`，`items`，`middlewares`，`pipelines`
  和一些通用方法，但各项目中的这些内容都大致相同，那为何不把它们统一整理在一起呢？我也想扩展一些功能，比如当 `spider`
  中添加字段后，不用再修改对应的 `item` 和 `pipeline` 甚至不用手动修改 `Mysql` 和 `PostgreSQL` 的表结构。

  项目的主旨是让开发者只需专注于 `spider` 脚本的编写，减少开发和维护流程。理想状态下，只需关注 `spider`
  中字段的解析规则和 `VIT` 下的 `.conf` 配置即可，**脱离无意义的重复操作**。

  以 `Mysql` 存储场景举例：可以自动创建相关数据库，数据表，字段注释，自动添加 `spider`
  中新添加的字段，和自动修复常见（字段编码，`Data too long`，存储字段不存在等）的存储问题。



  > `python 3.8+` 可以直接输入以下命令：

  ```shell
  pip install ayugespidertools
  ```

  > 可选安装1，安装数据库相关的所有依赖：

  ```shell
  pip install ayugespidertools[database]
  ```

  > 可选安装2，通过以下命令安装所有依赖：

  ```shell
  pip install ayugespidertools[all]
  ```

  *注：详细的安装介绍请查看[安装指南](https://ayugespidertools.readthedocs.io/en/latest/intro/install.html)。*



  > 开发人员只需根据命令生成示例模板，再配置相关设置即可。

  使用方法示例 `GIF` 如下：

  ![ayugespidertools.gif](https://raw.githubusercontent.com/shengchenyang/AyugeSpiderTools/master/examples/ayugespidertools-use.gif)

  对以上 `GIF` 中的步骤进行解释：

  ```shell

  ayuge version


  ayuge startproject <project_name>


  cd <project_name>



  cp /root/mytemp/.conf DemoSpider/VIT/.conf


  ayuge genspider <spider_name> <example.com>


  scrapy crawl <spider_name>

  ```

  具体的场景案例请在 [DemoSpider](https://github.com/shengchenyang/DemoSpider)
  项目中查看，也可以在 [readthedocs](https://ayugespidertools.readthedocs.io/en/latest/) 文档中查看教程。目前已适配以下场景：

  ```diff
  + 0).以下场景全支持从 nacos 或 consul 中获取配置，不一一举例。


  + 1).demo_one: 从 .conf 中获取 mysql 配置
  + 3).demo_three: 从 consul 中获取 mysql 配置
  + 21).demo_mysql_nacos: 从 nacos 中获取 mysql 配置
  + 5).demo_five: Twisted 异步存储示例
  + 24).demo_aiomysql: 结合 aiomysql 实现的 asyncio 异步存储示例
  + 13).demo_AyuTurboMysqlPipeline: mysql 同步连接池的示例


  + 2).demo_two: 从 .conf 中获取 mongodb 配置
  + 4).demo_four: 从 consul 中获取 mongodb 配置
  + 6).demo_six: Twisted 异步存储示例
  + 17).demo_mongo_async: 结合 motor 实现的 asyncio 异步存储示例


  + 22).demo_nine: 从 .conf 中获取 postgresql 配置
  + 23).demo_ten: Twisted 异步存储示例
  + 27).demo_eleven: asyncio 异步存储示例


  + 28).demo_es: 普通同步存储示例
  + 29).demo_es_async: asyncio 异步存储示例


  + 25). demo_oracle: 普通同步存储示例
  + 26). demo_oracle_twisted: Twisted 异步存储示例

  - 7).demo_seven: 使用 requests 来请求的场景(已删除，更推荐 aiohttp 方式)
  + 8).demo_eight: 同时存入 Mysql 和 MongoDB 的场景
  + 9).demo_aiohttp_example: 使用 aiohttp 来请求的场景
  + 10).demo_aiohttp_test: scrapy aiohttp 在具体项目中的使用方法示例

  + 11).demo_proxy_one: 快代理动态隧道代理示例
  + 12).demo_proxy_two: 测试快代理独享代理
  + 14).demo_crawl: 支持 scrapy CrawlSpider 的示例


  + 15).demo_item_loader: 本库中使用 Item Loaders 的示例
  - 16).demo_item_loader_two: 已删除，可查看 demo_item_loader，可方便的使用 Item Loaders 了

  + 18).demo_mq: 数据存入 rabbitmq 的模板示例
  + 19).demo_kafka: 数据存入 kafka 的模板示例
  + 20).demo_file: 使用本库 pipeline 下载图片等文件到本地的示例
  + 30).demo_file_sec: 自行实现的图片下载示例
  + 31).demo_oss: 使用本库 pipeline 上传到 oss 的示例
  + 32).demo_oss_sec: 自行实现的 oss 上传示例
  + 33).demo_oss_super: MongoDB 存储场景 oss 上传字段支持列表类型
  + 34).demo_conf: 支持从 .conf 中获取自定义配置
  ```



  前提：需要在 `tests` 的 `VIT` 目录下创建 `.conf` 文件，已给出示例文件，请填写测试所需内容，然后：

  - 可以直接使用 `tox` 来运行测试。
  - 本库以 [poetry](https://python-poetry.org/docs/) 开发，那么直接新环境下运行 `poetry install`
    后，手动运行目标测试或 `pytest` 命令来测试等皆可。
  - 也可以使用 `make` 工具，`make start` 然后 `make test` 即可。



  1. 若你觉得某些场景下的功能实现不太符合你的预期，想要修改或添加自定义功能，比如移除对你无用模块、修改库名等，你可以自行修改后 `build`。

  2. 本库主推 `scrapy` 扩展功能，在使用本库时，不会影响你 `scrapy` 项目及其它组件。

     也就是说，可使用本库开发原生的 `scrapy`，也可用 `scrapy` 的风格来开发，但还是推荐使用 `DemoSpider` 示例中的风格开发。不会对开发者造成过多的迁移成本。

  3. 代码测试覆盖率有点低，考虑增加吗？

     不考虑，场景所依赖服务太多，且云服务等其它因素导致个人维护成本过高，但不必担心，我会和本地服务的自动化测试结合使用。



  > 具体内容请以 [poetry 官方文档](https://python-poetry.org/docs/) 为准。

  据[你可能在意的事](#你可能在意的事)可知，你可以 `clone`
  源码后，修改任意方法（比如你的项目场景下可能需要其它的日志配置默认值，或添加其它的项目结构模板等），修改完成后 `poetry build`
  或 `make build` 即可打包使用。

  比如你可能需要更新依赖库中 `kafka-python` 为新版本 `x.x.x`，那只需 `poetry install`
  安装现有依赖后，再 `poetry add kafka-python==x.x.x` 安装目标版本（尽量不要使用 `poetry update kafka-python`
  ），确定测试正常了即可 `poetry build` 打包使用。

  > 其它自定义 scrapy 项目的方式

  也可以通过 `cookiecutter` 对项目个性化定制，可参考 [LazyScraper](https://github.com/shengchenyang/LazyScraper) 项目。

  **希望此项目能在你遇到扩展 scrapy 功能的场景时对你有所指引。**



  - [x] `scrapy` 的扩展功能场景
    - [x] `scrapy` 脚本运行信息统计和项目依赖表采集量统计，可用于日志记录和预警
    - [x] 自定义模板，在 `ayuge startproject <projname>` 和 `ayuge genspider <spidername>` 时生成适合本库的模板文件
    - [x] 从远程应用管理服务中获取项目配置
      - [x] 从 `consul` 获取项目配置
      - [x] 从 `nacos` 获取项目配置（注意：优先级小于 `consul`）
    - [x] 代理中间件（独享代理、动态隧道代理）
    - [x] 随机请求头 `UA` 中间件，根据 `fake_useragent` 中的权重来随机
    - [x] 使用以下工具来替换 `scrapy` 的 `Request` 来发送请求
      - [x] ~~`requests`: 这个不推荐使用，`requests` 同步库会降低 `scrapy` 运行效率~~（已移除此功能，更推荐 `aiohttp`
        的方式）
      - [x] `aiohttp`: 集成将 `scrapy Request` 替换为 `aiohttp` 的协程方式
    - [x] `Mysql` 存储的场景下适配
      - [x] 自动创建 `Mysql` 用户场景下需要的数据库和数据表及字段格式，还有字段注释
    - [x] `MongoDB` 存储场景适配
    - [x] `PostgreSQL` 存储场景适配
    - [x] `ElasticSearch` 存储场景适配
    - [x] `Oracle` 存储场景适配
    - [x] `oss` 上传场景适配
    - [x] `asyncio` 语法支持与 `async` 第三方库支持示例
      - [x] `spider` 中使用 `asyncio` 的 `aiohttp` 示例
      - [x] `pipeline` 中使用 `asyncio` 的 `aioMysql` 示例
    - [x] 集成 `Kafka`，`RabbitMQ` 等数据推送功能
  - [x] 常用开发场景
    - [x] `sql` 语句拼接，只用于简单场景。
    - [x] 数据格式化处理，比如：去除网页标签，去除无效空格等
    - [x] 字体反爬还原方法
      - [x] 基于 `ttf`，`woff` 之类的字体文件映射，或结合 `css` 等实现
        - [x] 可以直接在字体文件 `xml`
          中找到映射关系的：使用 [fontforge](https://github.com/fontforge/fontforge/releases) 工具导出映射即可。
        - [x] 无法找到映射关系的，则一般使用 `ocr` 识别（准确率非百分百），通过 `fontforge` 导出每个映射的 `png`
          ，后再通过各种方式识别。
      - [x] 字体反爬部分功能迁移到 `FontMapster` 项目中。
    - [x] `html` 数据处理，去除标签，不可见字符，特殊字符改成正常显示等
    - [x] 添加常用的图片验证码中的处理方法
      - [x] 滑块缺口距离的识别方法（多种实现方式）
      - [x] 根据滑块距离生成轨迹数组的方法
      - [x] 识别点选验证码位置及点击顺序
      - [x] 图片乱序混淆的还原方法示例

  注意：功能演示我将放入 [readthedocs](https://ayugespidertools.readthedocs.io/en/latest/) 文档中，以防此部分内容过多。



  如果此项目对你有所帮助，可以选择打赏作者。

  <img src="https://github.com/shengchenyang/AyugeSpiderTools/raw/master/artwork/ayugespidertools-donating.jpg" alt="微信赞赏码" width="280"/>


pkgId: af31b30f4d9ffd53f503d108095a2386763df5e5689ad06ce5c299ad9ae513bd
name: python-BAAlgorithmUtils
arch: src
version: 3.4.4
epoch: 0
release: 1
summary: Algorithm utils for python
url: https://github.com/BenArvin/BAAlgorithmUtils
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BAAlgorithmUtils-3.4.4-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/BAAlgorithmUtils.svg)](https://badge.fury.io/py/BAAlgorithmUtils)
  [![Build Status](https://travis-ci.com/BenArvin/BAAlgorithmUtils.svg)](https://travis-ci.com/github/BenArvin/BAAlgorithmUtils)

  Algorithm utils for python

  | Algorithm | Code file | Example |
  | :--- | :--- | :--- |
  | Tire tree | `TireTreeUtil.py` | `TireTreeUtilTest.py` |
  | --- | --- | --- |
  | KMP | `KMPUtil.py` | `KMPUtilTest.py` |
  | Boyer-Moore | `BMUtil.py` | `BMUtilTest.py` |
  | Horspool | `HorspoolUtil.py` | `HorspoolUtilTest.py` |
  | Aho-Corasick | `AhoCorasickUtil.py` | `AhoCorasickUtilTest.py` |
  | SBOM | `SBOMUtil.py` | `SBOMUtilTest.py` |
  | --- | --- | --- |
  | Binary Search Tree | `BSTUtil.py` | `BSTUtilTest.py` |
  | Adelson-Velsky and Landis Tree | `AVLTreeUtil.py` | `AVLTreeUtilTest.py` |
  | Red-Black Tree | `RBTreeUtil.py` | `RBTreeUtilTest.py` |
  | --- | --- | --- |
  | Bubble sort | `SortUtil.py` - `bubbleSort` | `SortUtilTest.py` |
  | Selection sort | `SortUtil.py` - `selectionSort` | `SortUtilTest.py` |
  | Quick sort | `SortUtil.py` - `quickSort` | `SortUtilTest.py` |
  | Bucket sort | `SortUtil.py` - `bucketSort` | `SortUtilTest.py` |

  Other utils:

  - `ClassUtil.py`


pkgId: 59b25167c8245861e51fe76176c5def372ec22c933568a5484e87fac91974da1
name: python-BAC0
arch: src
version: 2024.9.20
epoch: 0
release: 1
summary: BACnet Scripting Framework for testing DDC Controls
url: https://github.com/ChristianTremblay/BAC0
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BAC0-2024.9.20-1.src.rpm
checksum_type: sha256
description:
  [![Join the chat at https://gitter.im/ChristianTremblay/BAC0](https://badges.gitter.im/ChristianTremblay/BAC0.svg)](https://gitter.im/ChristianTremblay/BAC0?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  BAC0 is a asynchronous Python 3 (3.10 and over) scripting application that uses [BACpypes3](https://github.com/JoelBender/BACpypes3) to process BACnet™ messages on a IP network. This library brings out simple commands to browse a BACnet network, read properties from BACnet devices or write to them.

  Python is a simple language to learn and a very powerful tool for data processing. Coupled to BACnet, it becomes a great tool to test devices an interact with controllers.

  BAC0 takes its name from the default IP port used by BACnet/IP communication which is port 47808. In hexadecimal, it's written 0xBAC0.



  BAC0 is made for building automation system (BAS) programmers. Controllers used in this field are commonly called DDC Controllers (Direct Digital Control).

  Typical controllers can be programmed in different ways, depending on the manufacturer selling them (block programming, basic "kinda" scripts, C code, etc...). BAC0, is a unified way, using Python language and BACnet/IP communication, to interact with those controllers once their sequence is built.

  BAC0 allows users to simply test an application even if sensors are not connected to the controller. Using the out_of_service property, it's easy to write a value to the input so the controller will think an input is connected.

  It's also possible to do "manual commands" on output (often called overrides). In fact, every variable is exposed and seen by BAC0 and it's possible to interact with them using a simple scripting language or a complete unit test suite (like Pytest).

  Without a program like BAC0, you can rely on your DDC programming tool... but it is often slow and every test must be done manually. That means also that if you want to repeat the tests, the more complicated they are, the less chance you'll be able to do so.

  Now you can write your test and run them as often as you want. We'll show you how it works.



  As you will discover, when you define a controller in BAC0, you will get access to historical data of every variables in the controllers. Every points are trended every 10 seconds by default. Which means that you can do data analysis on everything while you're doing your startup. It allows to see performances and trouble really fast.

  This make BAC0 not only a good tool to test your sequence while your in the office. But also a really good tool to assist your startup, test and balancing. Using Jupyter Notebook, you'll even be able to create nice looking report right from your code.



  Connect BAC0 histories directly to a [InfluxDB](https://www.influxdata.com) v2.0 instance. It's then possible to use [Grafana](https://grafana.com) to explore your data.

  > **Note:** BACnet™ is a trademark of ASHRAE.


pkgId: 677ac4a986d02334623567f4fed94e7237648d7e65233bfcf40ce455f9075056
name: python-BAClangUtils
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Clang utils for parse Objective-C code
url: https://github.com/BenArvin/BAClangUtils
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BAClangUtils-1.0.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/BAClangUtils.svg)](https://badge.fury.io/py/BAClangUtils)
  [![Build Status](https://travis-ci.com/BenArvin/BAClangUtils.svg)](https://travis-ci.com/github/BenArvin/BAClangUtils)

  Clang utils for parse Objective-C code


  Run shell command get response and error silently.


  Parse OC code file by Clang and get all raw tokens.


pkgId: db0740e2ed3403878e7467bf3a007a3cf8599124c957a85febc81a54e5f76eed
name: python-BASC-Archiver
arch: src
version: 0.9.9
epoch: 0
release: 1
summary: Makes a complete archive of imageboard threads including images, HTML, and JSON.
url: https://github.com/bibanon/BASC-Archiver
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BASC-Archiver-0.9.9-1.src.rpm
checksum_type: sha256
description:
  The **BASC Archiver** is a Python library (packaged with the
  **thread-archiver** script) used to archive imageboard threads.
  It uses the `4chan API <https://github.com/4chan/4chan-API>`_
  with the py4chan wrapper. Developers are free to use the
  BASC-Archiver library for some interesting third-party applications,
  as it is licensed under the LGPLv3.
  It comes with a CLI interface for archiving threads, the
  **thread-archiver**, with a GUI interface under development.
  The **thread-archiver** is designed to archive all content from a 4chan
  thread:
  -  Download all images and/or thumbnails in given threads.
  -  Download all child threads (threads referred to in a post).
  -  Download a JSON dump of thread comments using the 4chan API.
  -  Download the HTML page.
  -  Convert links in HTML to use the downloaded images.
  -  Download CSS/JS and convert HTML to use them.
  -  Keep downloading until 404 (with a user-set delay).
  -  Can be restarted at any time.
  -  Threaded downloading to download multiple files at the same time.
  The **thread-archiver** replaces the typical “Right-click Save As, Web
  Page Complete” action, which does not save full-sized images or JSON. It
  works as a guerilla, static HTML alternative to Fuuka.


pkgId: 9474688bcb353208549a3b8e8793278254eb0733a736a100e41b7d85134588df
name: python-BASEmesh
arch: src
version: 2.2.0.post1
epoch: 0
release: 1
summary: Pre-processing and mesh generation toolkit for BASEMENT.
url: https://gitlab.ethz.ch/vaw/public/basemesh-v2/
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BASEmesh-2.2.0.post1-1.src.rpm
checksum_type: sha256
description:
  BASEmesh is a mesh generation and preprocessing toolkit for the numerical simulation package [BASEMENT](https://basement.ethz.ch/).



  - Generation of 2D quality meshes using Jonathan Shewchuk's [Triangle](https://www.cs.cmu.edu/~quake/triangle.html)
  - 2DM mesh interpolation via mesh and raster (DEM) elevation sources
  - Available as [QGIS](https://qgis.org/en/site/) plugin
  - Optional C extension module for acceleration
  - 1D channel generator [BASEchange](https://gitlab.ethz.ch/vaw/public/basemesh-v2/-/wikis/Command-line/BASEchange)



  As BASEmesh is available as both a Python module and QGIS plugin, the installation path depends on the version:



  1. Start QGIS
  2. Load the QGIS plugin manager by choosing *'Manage and Install Plugins…'* in the *'Plugins'* category of the QGIS toolbar
  3. Select *'Settings'* from the left panel
  4. Click on *'Add…'* and provide a descriptive name, e.g. 'BASEmesh Plugin Repository'
  5. Specify the repository address: <https://people.ee.ethz.ch/~basement/qgis_plugins/qgis_plugins.xml>
  6. Press OK to confirm; a new entry has been added to the list of plugin repositories (make sure the *Status* field reports as *connected* before continuing)
  7. Select *'All'* from the left panel of the plugin manager and search for ''BASEmesh''
  8. Choose the BASEmesh plugin (if several are available, choose the one with the highest version number) and press *'Install Plugin'*
  9. Close the plugin manager. A new toolbar should have appeared and a *'BASEmesh'* entry added to the *'Plugins'* category of the QGIS toolbar

  Alternatively, you can also find a ZIP version of a given BASEmesh release under the repository [Releases](https://gitlab.ethz.ch/vaw/public/basemesh-v2/-/releases) page, which can be installed using the *'Install from ZIP…'* option in the QGIS plugin manager.



  *Note: Installation of the Python module is not required for QGIS plugin use. It is only required for command line tools such as BASEchange or when using BASEmesh as a dependency for user code.*

  ```sh
  python -m pip install --user --upgrade basemesh
  ```



  > **Note:** This section only covers use of the QGIS plugin and related utilities.
  >
  > For usage instruction on the 1D channel generator, refer to the [BASEchange](https://gitlab.ethz.ch/vaw/public/basemesh-v2/-/wikis/Command-line/BASEchange) Wiki pages.
  >
  > If you wish to use BASEmesh as a dependency, it is recommended to locally build the [Python API Documentation](https://gitlab.ethz.ch/vaw/public/basemesh-v2/-/wikis/Python-API-Documentation) for detailed reference. Prior familiarity with the BASEmesh workflow via the plugin is recommended.



  The BASEmesh workflow consists of three steps:

  1. Elevation mesh generation (optional if you have raster elevation data)
  2. Quality mesh generation
  3. Mesh interpolation

  The following sections will cover the basics of how to use each tool. Note that this is purely a first introduction into the process and will skip a lot of the nuances regarding model setup and mesh generation. You can find additional information in the utilities' *'Help'* tab.

  Visit the [repository Wiki](https://gitlab.ethz.ch/vaw/public/basemesh-v2/-/wikis/home) for detailed guides and examples.

  If you are a seasoned user of BASEmesh v1.4.5, check out the [Migration guide](https://gitlab.ethz.ch/vaw/public/basemesh-v2/-/wikis/Migration-guide) for details on how to convert your existing projects for this version of BASEmesh.



  Elevation meshes are generated to represent the elevation geometry of your model. They provide an alternative to raster DEM data and allow the interpolation of a 2D quality mesh onto an elevated geometry.



  To generate an elevation mesh, you require input geometry in the form of 3D vector layers. These will generally take the form of 3D poly lines or points.

  If your input geometry is not 3D, you can use the *'Convert Legacy Layer (…)'* algorithms in the QGIS Processing Toolbox to add elevation information via layer attributes.



  By default, the elevation meshing utility will use the *'Keep convex hull'* mesh domain setting. This means that the outer edge of the generated mesh will equal the convex hull of your input data.

  This allows the generation of a mesh from point data only, but it will also "eat" any concavities, which is generally not an issue when using a single elevation data source.

  If you do require concavities, make sure you have a closed line string where you would like your mesh to end, then choose the *'Shrink to segments'* mesh domain setting. This will delete any geometries that are not contained within the outermost closed line string found. Note that this can "eat" your entire mesh if the outside line string is missing or has any gaps.



  If you know your input data is not perfect (which is highly likely with real-world GIS data), you can use the *'Snapping Tolerance'* setting to define a fuzz range at which geometry will be snapped to each other. The value set in the GUI is the exponent; a value of `-2` means that any points within `0.01` units will be considered coincident.



  The quality mesh defines the actual computational grid used for the simulation. It will always be flat, i.e. not contain any elevation information whatsoever.



  Quality meshing is entirely two-dimensional, any elevation information in the input data will be discarded if provided.

  Make sure that your break lines enclose the outside perimeter of your mesh.



  Any segment-bounded region in the mesh can be assigned a Material ID and element size constraint. This is done via a region marker point layer with the appropriate fields:

  | Field        | Description                                                                   | Type    |
  |--------------|-------------------------------------------------------------------------------|---------|
  | Hole marker  | Any region with a hole marker will be carved out of the resulting mesh        | Integer |
  | Material ID  | Used to define area-specific parameters such as friction or soil composition | Integer |
  | Maximum area | The maximum area of any mesh element in this region                           | Real    |



  String definitions are node strings used to keep track of specific cross-sections in the mesh, either to serve as a boundary condition or as an output.

  They are defined by named line string features in their own layer and will be automatically merged into the mesh break lines upon meshing.  After the meshing is complete, these line strings are then used to retrieve the mesh nodes that were generated along these break lines.

  You can include string definitions in the generated 2DM file (this is the required format for BASEMENT 3) or write them to a separate text file (for BASEMENT 2.8). You can also check both options if you wish to compare results from both versions.



  The mesh interpolation utility takes an existing, flat quality mesh and drapes it over an elevation source.

  This can either be a previously generated mesh layer, or a DEM raster layer and band.



  In this mode, only a single elevation source may be selected. If the quality mesh extends beyond the provided elevation source, meshing will fail.



  This mode has two panels, with the available elevation sources to the right and an empty list to the left.

  You can select any number of elevation sources from the right panel and drag them into the left in any order. Only elevation sources in the left panel will be used for interpolation, with the higher-ranked sources taking priority.

  For and point in the quality mesh that must be interpolated, the first elevation source is queried first. If it can produce a value, this value will be used right away, just as in Basic mode.

  If an elevation source cannot produce a value, the elevation source below it will be queried instead, until one manages to produce a value, or the entire list is exhausted.

  This allows for multi-source interpolation, e.g. an elevation mesh for the river itself, a fine-grid DEM for its immediate surroundings and a coarser DEM for floodplains further away.



  BASEMENT 2.8 only uses node elevation data, whereas BASEMENT 3 only uses element face elevation for its simulation.

  The *'Output mesh format'* drop down list may be used to select either or both elevation sources.

  Note that due to the node and element elevation being independent, the *'BASEMENT 2 and 3 (node and element elevation)'* setting will have roughly twice the execution time as either setting on its own.

  The mesh generated by the interpolation utility is now ready for use in BASEMENT, no additional exporting steps are necessary.


pkgId: 12ae08bcb75d5f10afa1d0e3ed44ea37f2d39c843b3b5ff2e9c194a79cde07bc
name: python-BDevManager2
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: A business development manager library
url: https://github.com/BlackFoxgamingstudio/BDevManager2.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BDevManager2-0.0.13-1.src.rpm
checksum_type: sha256
description:
  BDevManager2  is a A business development manager library designed to make prospecting, calling leads, saving notes, and developing new opportunities for your business...simple.

      1. gather 1000 leads from Linkedin
      2. order your leads in Excel and tag the top 100 prospects
      3. plan your week to call 10 at a time
      4. use this library to capture BANT (budget, Authority, Need, Timeline)
      5. put your results in to a system of record by the end of each day (use a CRM)
      6. call me if you need help closing business and making revenue:)
      7. repeat tell you to make all the money you need to be free:)


  Step 1 create a main.py file in your python project.
  Step 2 create a sales_leads.csv file with all of your leads (up to 1000)
  Step 3 add the following to your main.py file:

  ```
     from bdm_eng import LeadList, Top100ProspectLeads, Top10TargetsForTheWeek, TodayTarget, TodaysActivity, BANT, GameLoop


      leads = LeadList("sales_leads.csv")
      top_leads = Top100ProspectLeads()
      top_leads.add_leads(leads.process_leads())
      top_10_targets = Top10TargetsForTheWeek()
      top_10_targets.add_leads(top_leads.get_leads())
      today_target = TodayTarget(top_10_targets.get_leads())
      todays_activity = TodaysActivity()
      bant = BANT()
      game_loop = GameLoop(today_target, todays_activity, bant)
      game_loop.start()
  ```
  Step 4 install the libery by using: "pip3 install BDevManager2"
  Step 5 run program: "python3 main.py"


  When you run the program you will see a promote asking for user import on call notes:)

      Current target:  ['1', '<lead1 name>', '<lead1 email>', '<lead1 role>', '<lead1 phonenumber>', '<lead1 business>', '<lead1 title>']

      Enter 'e' to edit the target, 's' to save and move to the next target, or 'q' to quit:

  when you use the edit command you will see:
      Please enter budget notes:
          testdata
      Please enter authority notes:
          testdata
      Please enter needs notes:
          testdata
      Please enter timeline notes:
          testdata

  This libary helps you quickly capture your daily notes as you do business development task (calling new customers to build leads!)

  after you enter BANT you will see the saved output:

      [{'lead': ['1', '<lead1 name>', '<lead1 email>', '<lead1 role>', '<lead1 phonenumber>', '<lead1 business>', '<lead1 title>'], 'notes': {'budget_notes': 'testdata', 'authority_notes': 'testdata', 'needs_notes': 'testdata', 'timeline_notes': 'testdata'}}]

  then you will see the next lead in the dataset! its a Game Loop! this is the way! we can now define our leads for the day in a CSV file, and loop through the data easily, all as we save notes:) this process can scale out no mater the business or CRM being used by BDM's.

  Lastly, lets look at the final "daily Completed task list":

       [{'lead': ['1', '<lead1 name>', '<lead1 email>', '<lead1 role>', '<lead1 phonenumber>', '<lead1 business>', '<lead1 title>'], 'notes': {'budget_notes': 'testdata', 'authority_notes': 'testdata', 'needs_notes': 'testdata', 'timeline_notes': 'testdata'}},
       {'lead': ['2', '<lead1 name>', '<lead1 email>', '<lead1 role>', '<lead1 phonenumber>', '<lead1 business>', '<lead1 title>'], 'notes': {'budget_notes': 'testdata', 'authority_notes': 'testdata', 'needs_notes': 'testdata', 'timeline_notes': 'testdata'}},
       {'lead': ['3', '<lead1 name>', '<lead1 email>', '<lead1 role>', '<lead1 phonenumber>', '<lead1 business>', '<lead1 title>'], 'notes': {'budget_notes': 'testdata', 'authority_notes': 'testdata', 'needs_notes': 'testdata', 'timeline_notes': 'testdata'}}
       ]....

  now we can work as hard and as long as we want and have a runing list of completed task! go get that money! - The BlackFox


pkgId: bdbab237fe34604a927eb904e0f1acb8884eb7ce2c3414819197d9e8f1891bcd
name: python-BENPPy
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: BayesENproteomics in Python
url: https://github.com/VenkMallikarjun/BENPPy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BENPPy-1.0.7-1.src.rpm
checksum_type: sha256
description:
  Python implementation of BayesENproteomics.

  BayesENproteomics fits user-specified regression models of arbitrary complexity to accurately model protein and post-translational modification fold changes in label-free proteomics experiments. BayesENproteomics uses Elastic Net regularization and observation weighting based on residual size and peptide identification confidence, implemented via MCMC sampling from conditional distributions, to prevent overfitting.

  The initial proof-of-concept is described in our [preprint](https://www.biorxiv.org/content/early/2018/05/10/295527).


    * User-customised regression models to facilitate analysis of complex (or simple) experimental setups.
    * Protein and PTM run-level quantification (in addition to linear model fold change estimates) based on summation of user-specified effects.
    * No requirement to specify which PTMs to look for, BENPPy will automatically quantify any PTMs it can find (ideal for quantifying results obtained from unconstrained peptide search engines).
    * Option to utilise PyMC3-based NUTS sampler to fit a single customised model to an entire dataset (as opposed to the default option to fit protein-specific models), allowing the use of shared peptides (at the cost of very high RAM and CPU requirements).
    * MaxQuant compatibility.
    * Control group error propagation when calculating significance, if desired.
    * Option to use Bayes Factors instead of p-values, if desired.


  BENPPy is tested on Python 3.6 and requires [PyMC3](https://docs.pymc.io/). Both BENPPy and PyMC3 also have the following dependencies:
     - NumPy
     - SciPy
     - Pandas
     - Matplotlib
     - [Theano](http://deeplearning.net/software/theano/)



  Assuming a standard Python installation with pip and git, BENPPy can be installed via:

  `pip install git+https://github.com/VenkMallikarjun/BENPPy` or `pip install BENPPy`

  BENPPy can be imported by:

  `import BENPPy as bp`

  Depending on your installation, you may need to specify the environment vabiable 'MKL_THREADING_LAYER' to be 'GNU' in your IDE using `env MKL_THREADING_LAYER=GNU`.





  ::

      new_instance = bp.BayesENproteomics(output_name,    # String specifying a folder name within your working directory where output files will be stored (folder will be created if it doesn't already exist).
                                          form            # Can be either 'progenesis' (default) or 'maxquant' to specify the peptide list input format.
                                          )



  ::

      new_instance.doAnalysis(normalisation_peptides, # String specifying name of .csv file in format specified by 'form' containing peptides to be used for normalisation (can be the same as 'experimental_peptides').
                              experimental_peptides,  # String specifying name of .csv file in format specified by 'form' containing peptides to be used in quantitation.
                              organism,               # String specifying organism name. Can be 'human', 'mouse' or any UniProt proteome ID.
                              othermains_bysample,    # String specifying name of .csv file specifying additional main effects, with levels specified for each sample, to be included in model fitting. Defaults to ''.
                              othermains_bypeptide,   # String specifying name of .csv file specifying additional main effects, with levels specified for each peptide, to be included in model fitting. Defaults to ''.
                              otherinteractors,       # Dictionary specifying additional interacting parameters (E.g. {'Interactor1':'Interactor2','Interactor1':'Interactor3'}). Order of interactors does not matter. Defaults to {}.
                              regression_method,      # Can be either 'protein' (default) to fit separate models for each protein, or 'dataset' to fit a single model for entire dataset.
                              normalisation_method,   # Can be either 'median' (default) to normalise by median subtraction following log transformation, or 'none' to perform no normalisation.
                              pepmin,                 # Scalar specifying minimum number of peptides to fit a model for a protein. Proteins with fewer than pepmin peptides will be ignored. Defaults to 3.
                              ProteinGrouping,        # If ProteinGrouping is set to True, will treat all proteins with the same gene name as a single entity using all available peptides, otherwise each one will be calculated separately.
                              peptide_BHFDR,          # Scalar FDR cutoff employed to filter peptides before analysis. Defaults to 0.2.
                              nDB,                    # Scalar denoting number of databases used. Only modify this value if using earlier versions of Progenesis (<3.0). Defaults to 1.
                              incSubject,             # Bool denoting whether or not to include subject/run terms in model to be fit. Defaults to False.
                              subQuantadd,            # List of strings denoting which parameters to add to the 'Treatment' values to give subject-level quantification. Defaults to [''].
                              ContGroup,              # Bool denoting whether treatment variable specified in experimental_peptides headers is treated as a single continuous variable rather than multiple levels of a categorical variable. Defaults to False.
                              )

  * If `form = 'progenesis'` than `experimental_peptides` is simply the peptide (ion)-level output from Progenesis QI, both `experimental_peptides` and `normalisation_peptides` must be formatted the same. If `form = 'maxquant'` than `experimental_peptides` is a list containing the MaxQuant modificationSpecificPeptides.txt first and any [PTM]Sites.txt (E.g. `['modificationSpecificPeptides.txt','Oxidation (M)Sites.txt','Acetylation (K)Sites.txt']`) and `normalisation_peptides` takes the format of modificationSpecificPeptides.txt.


  By default BENPPy fits the following regularised model for each protein:

      `log_2(MS1 Intensity) = T + P + T*P + e`

  Where `T` and `P` are treatment and peptide effects recpectively and `T*P` represents the interaction between them, with `e` representing the error term.

  If `'dataset'` is specified for the `regression_method` arguement, the following model is fit for the entire dataset:

      `log_2(MS1 Intensity) = R + T + P T*R + T*P + e`

  Where `R` is the protein effect and `T*R` is the interaction between treatment and protein.

  These basic models can be extended by the user as desired by the `othermains_bysample` and `othermains_bypeptide` parameters. These are specified as strings containing the names of .csv files which contain columns of categorical identifiers with headers in the first row. Examples of how to specify othermains_bysample and othermains_bypeptide can be found in the examples folder (testsamplemains.csv and testpeptidemains.csv, respectively). Additional interaction effects can be specified by a dictionary in the `otherinteractors` parameter.

  BENPPy will perform both protein-, PTM- (if PTMs are in your dataset) and pathway-level quantification, exporting the respective results as .csv files as each step finishes.



  After `doAnalysis` finishes there will be several new properties added to the instance created in step 1 (and exported as .csv files to the folder specified by `output_name`).

  `new_instance`


  [Soon]


pkgId: ff39a8e23d2400477da583e80c0c978a3129c6050f20145a9e734f7681b2af4f
name: python-BFFuck
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Makes Brainfucking Easier!
url: https://github.com/none-None1/BFFuck
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BFFuck-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/bffuck)](https://pepy.tech/project/bffuck) [![Downloads](https://static.pepy.tech/badge/bffuck/month)](https://pepy.tech/project/bffuck) [![Downloads](https://static.pepy.tech/badge/bffuck/week)](https://pepy.tech/project/bffuck)


   Makes brainfucking easier

  The tools is an esoteric language that compiles to brainfuck, using algorithms in [brainfuck algorithms](https://esolangs.org/wiki/Brainfuck_algorithms).


  Run this in Python:
  ```python
  from bffuck import BFFuck
  bff=BFFuck()
  bf=bff.compile('Your code')
  ```

  Note that if a BFFuck object is created and used, its status will change and therefore cannot compile another program.

  BFFuck currently supports the following syntax:

  Comment:
  ```

  ```
  Variable definition:
  ```text
  <variable 1>=<variable 2>
  or
  <variable>=<number>
  ```

  Addition:
  ```text
  add(x,<number>)
  or
  add(x,<variable>)
  ```

  Subtraction:
  ```
  sub(x,<number>)
  or
  sub(x,<variable>)
  ```

  Multiplication:
  ```
  mul(x,<number>)
  or
  mul(x,<variable>)
  ```

  Modulo:
  ```
  mod(x,<number>)
  or
  mod(x,<variable>)
  ```

  While loop:
  ```text
  while(<variable or number>)
  CODE
  endwhile
  ```

  I/O:
  ```text
  <variable>=in # Reads <variable> as decimal integer
  <variable>=inc # Reads <variable> as ASCII character
  out(<variable or number>) # Outputs <variable> as decimal integer
  outc(<variable or number>) # Outputs <variable> as ASCII character
  ```

  String output shortcut:
  ```text
  print(STRING) # Without quotes

  print(Hello World!)
  ```

  If statement:
  ```text
  if(<variable or number>)
  CODE
  endif

  if(<variable or number>)
  CODE1
  else
  CODE2
  endif
  ```

  Comparison:
  ```text
  lt(x,<number>) # Compares x and the variable or number, if x is less than the variable or number, set x to 1, otherwise 0
  or
  lt(x,<variable>)

  eq(x,<number>) # Compares x and the variable or number, if x is equal to the variable or number, set x to 1, otherwise 0
  or
  eq(x,<variable>)
  ```

  Macros:
  ```text
  macro $<name> # Macro with no arguments
  CODE
  endmacro

  macro $<name>(<arg1>,<arg2>,...) # Macro with arguments
  CODE
  endmacro

  $<name> # Using a macro with no arguments
  $<name>(<arg1>,<arg2>,...) # Using a macro with arguments
  ```

  Memory:
  ```text
  ptr(a,b) # Store address of a to variable b
  ref(a,b) # Store value of address b to variable a
  set(a,b) # Set value of address b to a (variable or integer literal)
  ```

  Libraries
  ```text
  ?libraryname
  ```
  Includes the library `library name` (with file extension).

  It first searches the library in current directory, and then in the `stdlib` directory in the package.

  There are standard libraries for BFFuck, they are:
  * `env.bff` gets size of a "byte" specified by the compiler
  * `alloc.bff` allocates memory
  * `array.bff` manages memory using arrays
  * `rng.bff` a not very decent random number generator

  An example of the `rng.bff` library is here:
  ```text
  ?rng.bff
  x=0
  while(1)
  $rnd(x)
  outc(x)
  endwhile
  ```
  Prints random bytes.

  BFFuck is in **pure Python** and therefore it supports any platform.


  Programs compiled from BFFuck needs you to have 8 bit cells that wrap.


  BFFuck currently has these disadvantages:
  1. <s>It's numbers are 8 bit numbers.</s> You can choose 8-bit, 16-bit or 32-bit numbers using the `byte` keyword argument. But you need to run it on a 8-bit interpreter. <font color="red">REMEMBER: Using numbers with more bits is slower and increases the size of program largely! If you're using 32 bit, remember to use an extremely optimizing interpreter like bffsree!</font>
  2. It has some bugs.


  The repository contains some examples, including a Hello World program, a cat program and an A+B program.


pkgId: 4fed8f9e392f16af7a2dbabb55f609351cafcffa0ae1f13c0734840d2ef13fb6
name: python-BFPCode
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: 使Brainfuck语言与Python集成
url: https://pypi.org/project/BFPCode/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BFPCode-1.6.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/BFPCode?style=for-the-badge&logo=python&label=%E6%94%AF%E6%8C%81%E7%9A%84%20Python%20%E7%89%88%E6%9C%AC)
  ![PyPI - Version](https://img.shields.io/pypi/v/BFPCode?style=for-the-badge&logo=python&label=%E5%BD%93%E5%89%8D%E7%89%88%E6%9C%AC)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/BFPCode?style=for-the-badge&logo=pypi&label=PYPI%20%E4%B8%8B%E8%BD%BD%E9%87%8F%20%2F%20%E6%9C%88)
  ![Pepy Total Downlods](https://img.shields.io/pepy/dt/BFPCode?style=for-the-badge&logo=pypi&label=PYPI%20%E6%80%BB%E4%B8%8B%E8%BD%BD%E9%87%8F)
  ![PyPI - License](https://img.shields.io/pypi/l/BFPCode?style=for-the-badge&logo=gnu&label=%E5%BC%80%E6%BA%90%E5%8D%8F%E8%AE%AE&color=red)

  **BFPCode** 使Brainfuck语言与Python集成



  如果你想为BFPCode贡献自己的一份力量，欢迎提供反馈、报告问题或提交PR。



  BFPCode采用GNU Lesser General Public License v3 (LGPLv3)许可证。有关详细信息，请参阅[LICENSE](https://github.com/GudupaoSpark/BFPCode/blob/main/LICENSE)文件。



  - 项目页面：[![Static Badge](https://img.shields.io/badge/GitHub-gleen)](https://github.com/GudupaoSpark/BFPCode)
  - 包发布页面：[![Static Badge](https://img.shields.io/badge/PYPI-Link-blue)](https://pypi.org/project/BFPCode)
  - 作者：GuduapoSpark


pkgId: b73392273b78ddab8bceca4bb332427fe874af501957b5b179cdd2d60e48fc7d
name: python-BHBot
arch: src
version: 2.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Nick2bad4u/BHBot
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BHBot-2.3-1.src.rpm
checksum_type: sha256
description:
  [![Lint Code Base](https://github.com/Nick2bad4u/BHBot/actions/workflows/super-linter.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/super-linter.yml)
  [![Bandit](https://github.com/Nick2bad4u/BHBot/actions/workflows/bandit.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/bandit.yml)
  [![CodeQL](https://github.com/Nick2bad4u/BHBot/actions/workflows/codeql.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/codeql.yml)
  [![Dependabot Updates](https://github.com/Nick2bad4u/BHBot/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/dependabot/dependabot-updates)
  [![Dependency review](https://github.com/Nick2bad4u/BHBot/actions/workflows/dependency-review.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/dependency-review.yml)
  [![DevSkim](https://github.com/Nick2bad4u/BHBot/actions/workflows/devskim.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/devskim.yml)
  [![Generate xml sitemap](https://github.com/Nick2bad4u/BHBot/actions/workflows/sitemap.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/sitemap.yml)
  [![Greetings](https://github.com/Nick2bad4u/BHBot/actions/workflows/greetings.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/greetings.yml)
  [![Mark stale issues and pull requests](https://github.com/Nick2bad4u/BHBot/actions/workflows/stale.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/stale.yml)
  [![Microsoft Defender For Devops](https://github.com/Nick2bad4u/BHBot/actions/workflows/defender-for-devops.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/defender-for-devops.yml)
  [![OSSAR](https://github.com/Nick2bad4u/BHBot/actions/workflows/ossar.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/ossar.yml)
  [![pages-build-deployment](https://github.com/Nick2bad4u/BHBot/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/pages/pages-build-deployment)
  [![Pylint](https://github.com/Nick2bad4u/BHBot/actions/workflows/pylint.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/pylint.yml)
  [![Python application](https://github.com/Nick2bad4u/BHBot/actions/workflows/python-app.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/python-app.yml)
  [![Python Package using Conda](https://github.com/Nick2bad4u/BHBot/actions/workflows/python-package-conda.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/python-package-conda.yml)
  [![Scorecard supply-chain security](https://github.com/Nick2bad4u/BHBot/actions/workflows/scorecard.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/scorecard.yml)
  [![Semgrep](https://github.com/Nick2bad4u/BHBot/actions/workflows/semgrep.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/semgrep.yml)
  [![Sobelow](https://github.com/Nick2bad4u/BHBot/actions/workflows/sobelow.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/sobelow.yml)
  [![Upload Python Package](https://github.com/Nick2bad4u/BHBot/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Nick2bad4u/BHBot/actions/workflows/python-publish.yml)



  [Этот файл доступен на Русском языке](README_RU.md)

  Gold/XP farming bot for Brawlhalla

  Heavily inspired by [BrawlhallaEZ](https://github.com/jamunano/BrawlhallaEZ)








  **WARNING:** The software was originally developed for private utilization.
  While it is not designed to, it may potentially lead to unforeseen outcomes, including the execution of transactions within Mallhalla using in-game currencies.

  **The developers disclaims all liability for any damages that may arise from the use of this software. It is advised to proceed with caution and utilize the software at your own discretion.**

  (Bot has been tested by multiple people for over 3,000 hours without issue as of 4/18/2024)


  Latest release can always be downloaded [here](https://github.com/Nick2bad4u/BHBot/releases)



  - Works completely in background
  - Sends inputs directly to Brawlhalla to not disturb you
  - Automatically launches the game
  - Automatically creates/sets up lobby
  - Automatically picks/changes character and game duration
  - Automatically detects and resets xp limit
  - Supports custom modes
  - Supports custom languages
  - Even supports custom fonts
  - ~~Brews you coffee~~ (only tea supported for now)


  - The process is designed to be intuitive. Simply choose the required settings by clicking the "Settings" button
  - Once settings are saved, start the program by clicking on "Start" button


  - Bot requires "Collapse crossovers" to be set to Yes. If you think it should automatically set it to be so, please [open an issue](https://github.com/nick2bad4u/bhbot/issues)
  - Bot requires ingame language to be set to English. If you think it should automatically set it to be so, please [open an issue](https://github.com/nick2bad4u/bhbot/issues)


  - The underlying code is always available for review by anyone.
  - Essentially, the bot employs the Windows SendMessage API to transmit inputs directly to the Brawlhalla window. It utilizes pixel detection to discern states and determine the appropriate action at any given moment.

  - The BrawlhallaBot class can be utilized directly or you may develop a custom wrapper for it. It is designed to operate independently, with gui.py serving merely as a graphical wrapper using PySimpleGUI<img src="https://www.google-analytics.com/collect?v=2&tid=G-6RR5ZF4BJV&cid=555&t=event&en=eventName">


pkgId: fdac2a73a6799ea28787c8c8959aa0037a7e3ff57595cd059d85e6ae01f05c64
name: python-BINARY-DISTRIBUTION-TEMPLATE
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/BINARY-DISTRIBUTION-TEMPLATE/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BINARY-DISTRIBUTION-TEMPLATE-0.0.14-1.src.rpm
checksum_type: sha256
description:
  STRUCTURE:

  	BINARY_DISTRIBUTION_TEMPLATE
  		src
  			bin
  				BINARY_DISTRIBUTION_TEMPLATE



  setup.py:

  	from setuptools import setup, find_packages

  	setup (
  		version = "0.0.9",

  		name = "BINARY_DISTRIBUTION_TEMPLATE",
  		install_requires = [],

  		package_dir = {
  			'BINARY_DISTRIBUTION_TEMPLATE': 'src',
  		},
  		package_data = {
  			'BINARY_DISTRIBUTION_TEMPLATE': [ 'bin/BINARY_DISTRIBUTION_TEMPLATE' ]
  		},
  		scripts = [ 'src/bin/BINARY_DISTRIBUTION_TEMPLATE' ],

  		license = "",
  		long_description = "",
  		long_description_content_type = "text/plain"
  	)


pkgId: 42b664508dc2f6cd8fd44817bc6651b1210ee510fc658515f459ff47741b5655
name: python-BL-Python.all
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Python libraries for use in Boutros Lab.
url: https://github.com/uclahs-cds/BL_Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BL-Python.all-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A collection of Python libraries for creating web applications, working with databases, writing tests, and supporting utilities.



  **🚩** `BL_Python` has a minimum Python version requirement of `>= 3.10`.

  * Create a BL_Python [web application](src/web/README.md)
  * Contribute to [BL_Python Development](https://github.com/uclahs-cds/BL_Python/wiki/BL_Python-Development). Run `make` to get started!




  Following are each of the libraries in this repository.

  They can be used in Python under the `BL_Python` namespace. For example, to use the database libraries you would import from `BL_Python.database`.

  To use these packages during development of `BL_Python` itself, please refer to [Development](#development).


  Libraries for working with AWS.

  Review the `BL_Python.AWS` [readme](src/AWS/README.md)


  `bl-python.aws`


  `bl-python-aws@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/AWS`


  Libraries for working with SQLite and PostgreSQL databases.

  Review the `BL_Python.database` [readme](src/database/README.md)


  `bl-python.database`


  `bl-python-database@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/database`


  Utilities and tools for assisting in development of software.

  Review the `BL_Python.development` [readme](src/development/README.md)


  `bl-python.development`


  `bl-python-development@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/development`


  Utilities for working with the GitHub HTTP API. Uses `PyGithub` under the hood.

  Review the `BL_Python.GitHub` [readme](src/GitHub/README.md)


  `bl-python.github`


  `bl-python-github@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/GitHub`


  Libraries for PaaS offerings such as tools for altering application configurations.

  Review the `BL_Python.platform` [readme](src/platform/README.md)


  `bl-python.platform`


  `bl-python-platform@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/platform`


  Libraries used for writing software, such as pattern implementations so wheels don't need to be reinvented.

  Review the `BL_Python.programming` [readme](src/programming/README.md)


  `bl-python.programming`


  `bl-python-programming@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/programming`


  Libraries used to aid in automated testing.

  Review the `BL_Python.testing` [readme](src/testing/README.md)


  `bl-python.testing`


  `bl-python-testing@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/testing`


  Libraries used to building web applications.

  Review the `BL_Python.web` [readme](src/web/README.md)


  `bl-python.web`


  `bl-python-web@ git+ssh://git@github.com/uclahs-cds/BL_Python.git@main#subdirectory=src/web`



  Review [BL_Python Development](https://github.com/uclahs-cds/BL_Python/wiki/BL_Python-Development) for detailed information.


pkgId: cbe809205bd89666985f2021f8e0c14f651285c63c4ff6c626fc69c99406435c
name: python-BL-Python.platform
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Libraries for developing PaaS software in Boutros Lab.
url: https://github.com/uclahs-cds/BL_Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BL-Python.platform-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Libraries for developing PaaS software in Boutros Lab.



  During development of `BL_Python.platform`, you may need to explicitly install other `BL_Python` dependencies.

  If developing from the root repository, install with:
  - `pip install -e src/database`


pkgId: 0209b653fe06e0e4842ed4a2151d11d080857a21c07756238d17d630a6594f2f
name: python-BL-Python.web
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Libraries for building web applications in Boutros Lab.
url: https://github.com/uclahs-cds/BL_Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BL-Python.web-0.2.5-1.src.rpm
checksum_type: sha256
description:
  Libraries for building web applications in Boutros Lab.



  `BL_Python.web` includes a scaffolding tool to help you get started quickly.

  "Scaffolding" is a common practice using tools and automation to create and modify applications without requiring any initial programming.

  Review [Creating a New BL_Python.web Application](https://github.com/uclahs-cds/BL_Python/wiki/Creating-a-New-BL_Python.web-Application) for detailed information.



  `BL_Python.web` is intended to handle a lot of the boilerplate needed to create and run Flask applications. A primary component of that boilerplate is tying disparate pieces of functionality and other libraries together in a seamless way. For example, [SQLAlchemy](https://www.sqlalchemy.org/) is an ORM supported through `BL_Python.database` that this library integrates with to make database functionality simpler to make use of.



  `BL_Python.web` is based on [Flask 3.0.x](https://flask.palletsprojects.com/en/3.0.x/) and [Connexion 3.0.x](https://connexion.readthedocs.io/en/3.0.5/).



  Development dependencies can be installed with `[dev-dependencies]`. If developing from the core repository, use the command `pip install -e src/web[dev-dependencies]`.


pkgId: b580f829f29d3db1d6c71ce6699c086e6f61492b94a3857ff72b2743877035b0
name: python-BLAST-Lite
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Tool to model lifetime and degradation for commercial lithium-ion batteries.
url: https://github.com/NREL/BLAST-Lite
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BLAST-Lite-1.0.5-1.src.rpm
checksum_type: sha256
description:
  ![BLAST-Lite](assets/icon-blast.jpg)


  Battery Lifetime Analysis and Simulation Toolsuite (BLAST) provides a library of battery lifetime and degradation models for various commercial lithium-ion batteries from recent years. Degradation models are indentified from publically available lab-based aging data using NREL's battery life model identification toolkit. The battery life models predicted the expected lifetime of batteries used in mobile or stationary applications as functions of their temperature and use (state-of-charge, depth-of-discharge, and charge/discharge rates). Model implementation is in both Python and MATLAB programming languages. The MATLAB code also provides example applications (stationary storage and EV), climate data, and simple thermal management options. For more information on battery health diagnostics, prediction, and optimization, see [NREL's Battery Lifespan](https://www.nrel.gov/transportation/battery-lifespan.html) webpage.

  ![Example battery life predictions](assets/example_battery_life.png)



  Set up and activate a Python environment:

  ```
  conda create -n blast-lite python=3.12
  conda activate blast-lite
  ```

  Install BLAST-Lite via PyPI.
  In the environment created and activate above, run `pip install blast-lite`.



  The `blast.utils.get_nsrdb_temperature_data()` function uses an API key to access the NREL NSRDB for climate data for any requested location. If making many requests, please [get your own API key](https://developer.nrel.gov/signup) and replace the existing API key with yours in the 'examples\.hscfg' file. This configuration file is assumed by default to be in your 'home' folder, that is, the same folder as the code that is being run.

  If using a Windows machine, you may need to additionally run the following:

  `$ python -m pip install python-certifi-win32`.

  ```python
  import certifi
  import ssl
  import geopy

  ctx = ssl.create_default_context(cafile=certifi.where())
  geopy.geocoders.options.default_ssl_context = ctx
  ```



  Once the package is installed, you can generate an example usage dataset by running:

  ```python
  from blast import utils
  data = utils.generate_example_data()
  ```

  To see a list of available battery models, run:
  ```python
  from blast import models
  models.available_models()
  ```

  Select a model, instantiate a cell, and run the simulation:
  ```python
  cell = models.Lfp_Gr_250AhPrismatic()
  cell.simulate_battery_life(data)
  ```


  These battery models predict 'expected life', that is, battery life under nominal conditions. Many types of battery failure will not be predicted by these models:
  - Overcharge or overdischarge
  - Impact of physical damage, vibration, or humidity
  - Operating outside of manufacturer performance and environmental limits, such as voltage, temperature, and charge/discharge rate limits
  - Pack performance loss due to cell-to-cell inbalance

  Aging models are generally trained on a limited amount of data, that is, there is not enough information to estimate cell-to-cell variability in degradation rates.
  Battery 'warranty life' is generally much more conservative than 'expected life'.
  These models are estimating cell level degradation, there will be additional performance penalties and caveats for estimating lifetime of battery packs.
  A good rule-of-thumb is to assume that pack lifetime is 20-30% less than cell lifetime, but please support model simulations with data if you have it.


   - Sony Murata LFP-Gr battery aging data and model
       - [Calendar aging data source](https://doi.org/10.1016/j.est.2018.01.019)
       - [Cycle aging data source](https://doi.org/10.1016/j.jpowsour.2019.227666)
       - [Model identification source](https://doi.org/10.1149/1945-7111/ac86a8)
   - Nissan Leaf LMO-Gr (2nd life cells) battery aging data
       - [Calendar aging data source](https://doi.org/10.1109/EEEIC/ICPSEUROPE54979.2022.9854784)
       - [Cycle aging data source](https://doi.org/10.1016/j.est.2020.101695)
   - Panasonic NCA-Gr battery aging data
       - [Calendar aging data source](https://dx.doi.org/10.1149/2.0411609jes)
       - [Cycle aging data source](https://doi.org/10.1149/1945-7111/abae37)
   - [Sony Murata NCA-GrSi battery aging data](https://doi.org/10.1016/j.jpowsour.2022.232498)
       - Additional research by TUM on [mechanistic cycling](https://doi.org/10.1016/j.jpowsour.2023.233947) and [mechanistic calendar aging](https://doi.org/10.1016/j.jpowsour.2023.233208) models is not replicated here
   - [Commercial NMC-LTO battery aging data source](https://doi.org/10.1016/j.jpowsour.2020.228566)
   - [Kokam NMC111-Gr battery aging data source](https://ieeexplore.ieee.org/iel7/7951530/7962914/07963578.pdf)
   - [Sanyo NMC111-Gr battery aging model source](http://dx.doi.org/10.1016/j.jpowsour.2014.02.012)
   - [LG MJ1 NMC811-GrSi battery aging data source](https://everlasting-project.eu/wp-content/uploads/2020/03/EVERLASTING_D2.3_final_20200228.pdf)
   - Models of commercially produced (> 1 GWh / yr manufacturers), large format Li-ion cells from a [2023 Journal of Energy Storage paper](https://doi.org/10.1016/j.est.2023.109042)
      - 250 Ah LFP-Gr (high energy density, very low power)
      - 75 Ah NMC-Gr 'A' (relatively high power, suitable for fast charging)
      - 50 Ah NMC-GR 'B1' (relatively high power, suitable for fast charging)
      - 50 Ah NMC-Gr 'B2' (higher energy density than B1 but lower power, questionable performance and durability under fast charging demands)
   - Stationary storage battery use profiles are [provided open-source](https://dataserv.ub.tum.de/index.php/s/m1510254) by [Kucevic et al](https://www.sciencedirect.com/science/article/pii/S2352152X19309016)
   - Electric vehicle battery use profiles were generated using NREL's [FASTSim tool](https://www.nrel.gov/transportation/fastsim.html).


  Paul Gasper, Nina Prakash, Kandler Smith

  NREL SWR-22-69

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


pkgId: 608e634e0c435b496ccecc64cbf373d5f20328b3211933286ccabce335b3f4ca
name: python-BMCTool
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A python tool to perform Bloch-McConnell (BMC) simulations.
url: https://github.com/schuenke/BMCTool
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BMCTool-0.6.1-1.src.rpm
checksum_type: sha256
description:
  This repository contains a purely python-based Bloch-McConnell (BMC) simulation tool that can be used to simulate
  the evolution of the magnetization in various (exchanging) magnetic environments ('pools') under arbitrary
  radio-frequency (RF) irradiation. The tool was developed to simulate Chemical Exchange Saturation Transfer (CEST) or
  related spectra, but can be used for many other MR simulations as well.

  The BMCTool utilizes the [pulseq](https://pulseq.github.io/) open file format to define and store all events (RF pulses,
  gradients, delays, ADCs) that shall be simulated. The scanner settings and characteristic properties of the magnetic
  environments (relaxation times, pool size fractions, exchange rates) are defined and stored in config-files in the
  [YAML](https://yaml.org) file format.

  Every simulation requires exactly one seq-file (containing all events) and at least one config-file.



  The BMCTool can be installed from [PyPi](https://pypi.org/) using

  ``
  pip install bmctool
  ``



  To make sure that the installation was successful, you can run an example simulation that is provided with both,
  the installation using pip and GitHub. To run an example simulation, simply execute the following code:

  ```python
  from bmctool.simulate import sim_example
  sim_example()
  ```

  The sim_example function uses the [WASABI.seq](bmctool/library/seq-library/WASABI.seq)
  and [config_wasabi.yaml](bmctool/library/sim-library/config_wasabi.yaml) example files. The generated plot should look
  like this:

  ![](https://raw.githubusercontent.com/schuenke/BMCTool/master/examples/example_wasabi_spectrum.png "Example WASABI spectrum")



  All simulations using the BMCTool require a config file (in the *yaml* format) that includes all simulation settings
  and a sequence file (in the *seq* format), which defines the events to be simulated. An
  [example seq-file](bmctool/library/seq-library/WASABI.seq) and an
  [example yaml file](bmctool/library/sim-library/config_wasabi.yaml) can be found in the [library](bmctool/library)
  subfolder. For more information about config and sequence files and about the
  [pulseq-cest-library](library/pulseq-cest-library), where both types of files are shared, please read the
  **Pulseq-CEST Library** section below.

  If you created your own files or downloaded them from the [pulseq-cest-library](https://github.com/kherz/pulseq-cest-library),
  you can start the simulation by running the following code:

  ```python
  from bmctool.simulate import simulate
  config_path = '<path_to_your_config>'  # can be a str or a Path
  seq_path = '<path_to_your_sequence>'  # can be a str or a Path
  sim = simulate(config_file=config_path, seq_file=seq_path, show_plot=True)
  ```

  The simulate function accepts several additional keyword arguments (**kwargs), that allow to adjust the plot.
  These are for example *normalize* (bool: toggle normalization), *norm_threshold* (value/list/array: threshold for
  normalization offsets), *offsets* (list/array: manually defined x-values), *invert_ax* (bool: toggle invert ax),
  *plot_mtr_asym* (bool:toggle plot MTR_asym) and *title*, *x_label*, *y_label* to control the lables.

  The [examples folder](examples) in the [BMCTool GitHub repository](https://github.com/schuenke/BMCTool) contains some
  further simulation examples as well as an example script to create your own *WASABI.seq* file. _Please note that this
  file will include an additional normalization offset at -300 ppm. To use this for normalization in the simulation,
  simply add the kewword argument ``normalize=True`` to the simulate function._



  The BMCTool was developed in parallel to the [pulseq-cest project](https://pulseq-cest.github.io/) that aims to provide
  published and approved CEST saturation blocks in the [pulseq](https://pulseq.github.io/) open file format to enable an
  exact comparison of CEST saturation blocks with newly developed or adapted saturation blocks for reproducible research.
  The [pulseq-cest project](https://pulseq-cest.github.io/) provides a [MATLAB implementation](https://github.com/kherz/pulseq-cest)
  and a [python implementation](https://github.com/KerstinHut/pypulseq-cest). The python implementation uses the
  [BMCTool](https://github.com/schuenke/BMCTool) and [pypulseq](https://github.com/imr-framework/pypulseq) for config and
  seq file handling. Both, the MATLAB and python implementation use the same Bloch-McConnell equation solver implemented
  in C++, which is much faster than the solver implemented in the BMCTool itself. For extensive simulations we thus
  recommend checking out the [pulseq-cest implementations](https://pulseq-cest.github.io/).



  You will find several pre-defined and approved CEST pre-saturation schemes and simulation configs in the
  [pulseq-cest-library GitHub repository](https://github.com/kherz/pulseq-cest-library). You can clone the library using

  ``
  git clone https://github.com/kherz/pulseq-cest-library.git
  ``

  or directly download the latest version as a [ZIP file](https://github.com/kherz/pulseq-cest-library/archive/master.zip).


pkgId: 72280a2a5aca44a2865dbcde8d8885a341c1c8fe562e05862fc1a6bb83aaadaf
name: python-BMI160-i2c
arch: src
version: 0.6
epoch: 0
release: 1
summary: A I2C driver library to use the BMI160 sensor (acclerometer/gyro) with python on a raspberrypi
url: https://github.com/lefuturiste/BMI160-i2c
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BMI160-i2c-0.6-1.src.rpm
checksum_type: sha256
description:
  I2C library to use the Inertial Mesurment Unit BMI160. Heavily inspired on @serioeseGmbH code [serioeseGmbH/BMI160](https://github.com/serioeseGmbH/BMI160), in fact I just adapted his code.

  This library was tested successfully on a Raspberry Pi 3 B



  The package is [available on pypi.org](https://pypi.org/project/BMI160-i2c).

  You can install this package using this command

  `python3 -m pip install BMI160-i2c`

  **This library require [smbus](https://github.com/kplindegaard/smbus2)**

  Install smbus2 using the following command:

  `python3 -m pip install smbus2`



  Wire the breakout board with these lines : GND, 3V3, SAO (to GND), SDA, SCL

  Make sure that the device is available at `0x68` or `0x69` i2c address by running this command:

  `i2cdetect -y 1`

  Example : A little python script to fetch all 6 values from the sensor :

  ```python
  from time import sleep
  from BMI160_i2c import Driver

  print('Trying to initialize the sensor...')
  sensor = Driver(0x68) # change address if needed
  print('Initialization done')

  while True:
    data = sensor.getMotion6()
    
    print({
      'gx': data[0],
      'gy': data[1],
      'gz': data[2],
      'ax': data[3],
      'ay': data[4],
      'az': data[5]
    })
    sleep(0.1)
  ```



  There is so many method available to do whatever you want to do with a sensor of this kind.

  Look at all the methods available [here](https://github.com/lefuturiste/BMI160-i2c/blob/master/BMI160_i2c/__init__.py).



  - [hanyazou/BMI160-Arduino](https://github.com/hanyazou/BMI160-Arduino/)
  - [serioeseGmbH/BMI160](https://github.com/serioeseGmbH/BMI160)
  - [IMU BMI160 Bosch product page](https://www.bosch-sensortec.com/products/motion-sensors/imus/bmi160.html)
  - [BMI160 Datasheet](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi160-ds000.pdf)
  - [smbus2 docs](https://smbus2.readthedocs.io/en/latest/)



  Feel free to open a issue or a pull request I will be happy to answer any questions or help you with this library.

  You can also use these alternative methods to contact me:

  - Twitter: [@_le_futuriste](https://twitter.com/_le_futuriste)

  - Discord: `lefuturiste#5297`

  - Discord server: [https://discord.gg/9M4vVsX](https://discord.gg/9M4vVsX)



  - Increment the version used in `setup.py`
  - Build the package: `python3 setup.py sdist bdist_wheel`
  - Publish the package: `python3 -m twine upload dist/*`
  - Enter `__token__` for the username
  - Enter `pypi-{....}` for the password
  - And tada!


pkgId: 193eaf71ef41a7aebedab98c04e2ff6ade1e31690f4c3b12ee4ba4d11600ea34
name: python-BMI500caonia
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: BMI500 HW4
url: https://github.com/shaoyanpan/BMI500-HW4
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BMI500caonia-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This package is an example Kmeans' package for BMI500's project in Emory University. The package will automatically download the iris data collected from UCI. The dataset contains three classes of flowers, and the clustering algorithm is to seperate each group of the flowers. It does not necessary tell you what kind of flower is, but will tell you which flowers are in a same group.





  In your command line, type "pip install BMI500caonia"



  python

  from BMI500caonia import BMI500clustering

  BMI500clustering.Kmeans_run(n, iteration, random_state)

  (n is the number of clusters, iteration is the number of iteration, random_state is the number of random initializations)



  The running time is 14 seconds in Titan'x 12 GB gpu and Intel Iris 16 GB cpu.



  The function should be modified to be more flexible in the future, so the user can customize parameters.


pkgId: 7ecd42a2ee791b37b8fd801d95c1c80802ac06a996d3ea11399b009d60a14bc6
name: python-BMKG-earthquake-update
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://github.com/madshopy/latest-indonesia-earthquake/tree/main
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BMKG-earthquake-update-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  this package will get the latest earthquake from BMKG -Meteorology, Climatology, and Geophysics Agency

description:
  this package will get the latest earthquake from BMKG -Meteorology, Climatology, and Geophysics Agency



  This package uses beautifllsoup4 and a request which will produce a jSON file output that is ready to be used for web or mobile applications


pkgId: ee8dfc7b1ef250344594ef0a0ddeaad911d9758e1409540e41bac771104e69e5
name: python-BMSS
arch: src
version: 2.0.17
epoch: 0
release: 1
summary: A package for dyanmic model analysis.
url: https://github.com/EngBioNUS/BMSS2
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BMSS-2.0.17-1.src.rpm
checksum_type: sha256
description:
  This package supports routine building and analysis of kinetic models for biological systems. This includes simulation, sensitivity analysis, model selection and identifiability analysis. The whole package is database-driven which allows one to interactively retrieve, store and update model information and implementation from/into SQL databases to ensure reproducibility and reusability, particularly for ease of model selection.

  __*Note:*__ An extensible web app database listing some of the pre-established models can be found at https://sbr.syncti.org/bmss2

  ![alt text](https://github.com/EngBioNUS/BMSS2/blob/master/BMSSDiagram.png?raw=true)


  The documentation can be found at https://engbionus-bmss.readthedocs.io/en/latest/BMSS.html


  * Database-driven model manipulation and storage
  * Model simulation
  * Sensitivity analysis
  * Parameter estimation using Bayesian Inference
  * Model selection
  * Trace analysis for _a_ _posteriori_ identifiability analysis
  * Strike-GOLDD algorithm in Python for _a_ _priori_ identifiability analysis
  * Support read/export of models in SBML format and model export in COMBINE archive

  For more information, refer to the BMSS2 documentation. If you wish to know more about our work, visit the [NUS Engineering Biology Lab website](https://engbio.syncti.org).


  Spyder IDE from Anaconda Distribution [Anaconda Installation]

  Recommended: Python 3.7 and above.


  Install the dependent packages using pip as shown below.
  ```
  pip install numpy matplotlib seaborn pandas numba scipy SALib dnaplotlib pyyaml synbiopython
  ```


  If you wish to put your code in notebook format, install Jupyter using pip as shown below.
  ```
  pip install jupyter
  ```
  or if you are using Anaconda:
  ```
  conda install jupyter
  ```

  [Anaconda Installation]: <https://www.anaconda.com/products/individual>


  The examples folder contains
  * Step-by-step explanations of BMSS2's functionalities labeled as tutorials
  * Case studies for the characterization of common genetic constructs labeled as examples.



  Copyright __*2020 EngBioNUS*__

  Licensed under the __Apache License, Version 2.0__ (the "License"); you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  ```
      http://www.apache.org/licenses/LICENSE-2.0
  ```
  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


  Please feel free to contact us at EngBioBMSS.help@gmail.com if you have any questions or to report any bugs.

  [guidelines for contributing]: <https://github.com/EngBioNUS/BMSS2/blob/master/contributing.md>


  Anyone and everyone is welcome to contribute. Please review the [guidelines for contributing]


pkgId: a14235733e0fc63b934a16d795bb6965b9016ae5d42ce3df3711229cc99e2749
name: python-BNumMet
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Basic Numerical Methods for Python 3
url: https://github.com/fbpazos/Trabajo-Fin-Master/tree/main/Python_BNumMet
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BNumMet-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <!-- TOC start -->
  - [Introduction](#introduction)
  - [Installation](#installation)
    * [PyPi Package Manager](#pypi-package-manager)
    * [Manual Installation](#manual-installation)
  - [Continue Development](#continue-development)
    * [Run Tests](#run-tests)
  - [BNumMet - Structure](#bnummet---structure)
  - [Usage & Examples](#usage--examples)
    * [Linear Systems](#linear-systems)
    * [Interpolation](#interpolation)
    * [Non-Linear](#non-linear)
    * [Randomness](#randomness)
    * [Visualizers](#visualizers)
      + [Linear Systems](#linear-systems-1)
      + [Interpolation](#interpolation-1)
      + [Non-Linear](#non-linear-1)
      + [Least Squares](#least-squares)
      + [Randomness](#randomness-1)
  - [SonarQube](#sonarqube)
    * [Start the SonarQube server (Docker Version)](#start-the-sonarqube-server-docker-version)
    * [Run the analysis](#run-the-analysis)
  <!-- TOC end -->


pkgId: dcb4db07874688167240631dd37859f8973cf366bba68cb017696899ff29edb6
name: python-BO4E-Python-Generator
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: This tool auto generates (customizable) pydantic v2 Code to implement the BO4E-Schemas.
url: https://github.com/bo4e/bo4e-python-generator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BO4E-Python-Generator-0.0.13-1.src.rpm
checksum_type: sha256
description:
  <!--- you need to replace the `organization/repo_name` in the status badge URLs --->

  ![Unittests status badge](https://github.com/bo4e/BO4E-Python-Generator/workflows/Unittests/badge.svg)
  ![Coverage status badge](https://github.com/bo4e/BO4E-Python-Generator/workflows/Coverage/badge.svg)
  ![Linting status badge](https://github.com/bo4e/BO4E-Python-Generator/workflows/Linting/badge.svg)
  ![Black status badge](https://github.com/bo4e/BO4E-Python-Generator/workflows/Formatting/badge.svg)

  This is a template repository.
  It doesn't contain any useful code but only a minimal working setup for a Python project including:

  - a basic **project structure** with
    - tox.ini
    - requirements.in
    - and a requirements.txt derived from it
    - an example class
    - an example unit test (using pytest)
  - ready to use **Github Actions** for
    - [pytest](https://pytest.org)
    - [code coverage measurement](https://coverage.readthedocs.io) (fails below 80% by default)
    - [pylint](https://pylint.org/) (only accepts 10/10 code rating by default)
    - [mypy](https://github.com/python/mypy) (static type checks where possible)
    - [black](https://github.com/psf/black) code formatter check
    - [isort](https://pycqa.github.io/isort/) import order check
    - [codespell](https://github.com/codespell-project/codespell) spell check (including an ignore list)
    - ready-to-use publishing workflow for pypi (see readme section below)

  By default, it uses Python version 3.12.



  This introduction assumes that you have tox installed already (
  see [installation instructions](https://tox.readthedocs.io/en/latest/installation.html)) and that a `.toxbase` environment
  has been created.
  `.toxbase` is a project independent virtual environment-template for all the tox environments on your machine. If anything is weird during the tox installation or after the installation, try turning your computer off and on again before getting too frustrated.

  Also on new windows machines it is possible that the execution policy is set to restricted and you are not allowed execute scripts. You can find detailed information [here](https://learn.microsoft.com/de-de/powershell/module/microsoft.powershell.core/about/about_execution_policies?view=powershell-7.3).

  If this is the case, clone this repository and create the `dev` environment on your machine.

  ```bash
  tox -e dev
  ```



  1. Create a new project using existing sources with your local working copy of this repository as root directory. Choose
     the path `your_repo/.tox/dev/` as path of the "previously configured interpreter".
  2. Set the
     default [test runner of your project](https://www.jetbrains.com/help/pycharm/choosing-your-testing-framework.html) to
     pytest.
  3. Set the `src` directory as sources root (via right click, [docs](https://www.jetbrains.com/help/pycharm/content-root.html)).
  4. Set
     the [working directory of the unit tests](https://www.jetbrains.com/help/pycharm/creating-run-debug-configuration-for-tests.html)
     to the project root (instead of the unittest directory).



  1. Open the folder with VS Code.
  2. **Select the python interpreter** ([official docs](https://code.visualstudio.com/docs/python/environments#_manually-specify-an-interpreter)) which is created by tox. Open the command pallett with `CTRL + P` and type `Python: Select Interpreter`. Select the interpreter which is placed in `.tox/dev/Scripts/python.exe` under Windows or `.tox/dev/bin/python` under Linux and macOS.
  3. **Setup pytest and pylint**. Therefore we open the file `.vscode/settings.json` which should be automatically generated during the interpreter setup. Insert the following lines into the settings:

  ```json
  {
    "python.testing.unittestEnabled": false,
    "python.testing.nosetestsEnabled": false,
    "python.testing.pytestEnabled": true,
    "pythonTestExplorer.testFramework": "pytest",
    "python.testing.pytestArgs": ["unittests"],
    "python.linting.pylintEnabled": true
  }
  ```

  4. Create a `.env` file and insert the following line

  For Windows:

  ```
  PYTHONPATH=src;${PYTHONPATH}
  ```

  For Linux and Mac:

  ```
  PYTHONPATH=src:${PYTHONPATH}
  ```

  This makes sure, that the imports are working for the unittests.
  At the moment I am not totally sure that it is the best practise, but it's getting the job done.

  5. Enjoy 🤗



  This repository contains all necessary CI steps to publish any project created from it on PyPI.
  It uses the trusted publishers workflow as described in the [official Python documentation](https://packaging.python.org/guides/publishing-package-distribution-releases-using-github-actions-ci-cd-workflows/).
  It just requires some manual adjustments/settings depending on your project:

  1. Fill out the metadata in the [`pyproject.toml`](pyproject.toml); Namely the package name and the dependencies which should be in sync with your `requirements.in`.
  2. Uncomment the lines in [`.github/workflows/python-publish.yml`](.github/workflows/python-publish.yml)
  3. Create a [new environment in your GitHub repository](https://github.com/Hochfrequenz/python_template_repository/settings/environments) and call it `release`.
  4. Set up a new trusted publisher [in your PYPI account](https://pypi.org/manage/account/publishing/).
     1. PyPI Project Name: The name which you defined in the `pyproject.toml` is the name of the project which you have to enter here.
     2. Owner: The GitHub organization name or GitHub username that owns the repository
     3. Repository name: The name of the GitHub repository that contains the publishing workflow
     4. Workflow name: The filename of the publishing workflow. This file should exist in the .github/workflows/ directory in the repository configured above. Here in our case: `python-publish.yml`
     5. Environment name: The name of the GitHub Actions environment that the above workflow uses for publishing. Here in our case: `release`
  5. Now create a release by clicking on "Create new release" in the right Github sidebar (or visit `github.com/your-username/your-reponame/releases/new`). This should trigger the workflow (see the "Actions" tab of your repo).
  6. Check if the action failed. If it succeeded your PyPI account should now show the new project. It might take some minutes until the package can be installed via `pip install packagename` because the index has to be updated.
  7. Now create another PyPI token with limited scope and update the Github repository secret accordingly.



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


pkgId: e48ce63cc2b4c6ac414e64ad9414c9e6d2fff0390df71a105a10103d3052c8e7
name: python-BO4E-Schema-Tool
arch: src
version: 0.0.9
epoch: 0
release: 1
url: https://github.com/Hochfrequenz/BO4E-Schema-Tool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BO4E-Schema-Tool-0.0.9-1.src.rpm
checksum_type: sha256
summary:
  This little (python) tool allows to conveniently pull the BO4E-Schemas of a certain version and to edit them in certain ways.

description:
  ![Unittests status badge](https://github.com/Hochfrequenz/BO4E-Schema-Tool/workflows/Unittests/badge.svg)
  ![Coverage status badge](https://github.com/Hochfrequenz/BO4E-Schema-Tool/workflows/Coverage/badge.svg)
  ![Linting status badge](https://github.com/Hochfrequenz/BO4E-Schema-Tool/workflows/Linting/badge.svg)
  ![Black status badge](https://github.com/Hochfrequenz/BO4E-Schema-Tool/workflows/Formatting/badge.svg)

  This little command line tool enables you to conveniently pull BO4E-Schemas of arbitrary versions.
  Additionally, it supports some features to edit those schemas which can be defined by config values.




  - Pull BO4E-Schemas of arbitrary versions
    - references in `$ref` will be replaced by relative paths
  - Edit schemas:
    - Define non nullable properties (in most cases changes it to a required field)
    - Add additional properties (keep in mind that you should avoid this if possible)
    - Add additional models (keep in mind that you should avoid this if possible)
    - All features also apply to Enums



  This tool is a command line tool. You can use it by installing `BO4E-Schema-Tool` it from
  [pip](https://pypi.org/project/BO4E-Schema-Tool/) via
  ```bash
  pip install BO4E-Schema-Tool
  ```
  and then running:
  ```bash
  > bost --help
  Usage: bost [OPTIONS]

    Entry point for the bost command line interface.

  Options:
    -o, --output DIRECTORY          Output directory to pull the JSON schemas into
                                    [required]
    -t, --target-version TEXT       Target BO4E version. Defaults to latest.
    -c, --config-file FILE          Path to the config file
    -r, --update-refs / -R, --no-update-refs
                                    Automatically update the references in the
                                    schema files. Online references to the BO4E
                                    schemas will be replaced by relative paths.
                                    References to $definitions or $defs must
                                    exists as explicit schemas in the namespace as
                                    well and will be replaced by relative paths to
                                    them. The definitions will be removed.
    -d, --set-default-version / -D, --no-set-default-version
                                    Automatically set or overrides the default
                                    version for '_version' fields with --target-
                                    version. This is especially useful if you want
                                    to define additional models which should
                                    always have the correct version.
    --clear-output                  Clear the output directory before saving the
                                    schemas
    --cache-dir DIRECTORY           Path to the optional cache dir. If not set the
                                    cache is disabled. It will cache the raw
                                    schema files downloaded from github.
    --token TEXT                    A GitHub Access token to authenticate with the
                                    GitHub API. Use this if you have problems with
                                    the rate limit. Alternatively, you can set the
                                    environment variable GITHUB_ACCESS_TOKEN.
    --version                       Show the version and exit.
    --help                          Show this message and exit.
  ```
  Alternatively, you can run the code from your python code by calling `bost.main()` with the same arguments as above.



  The config file is a JSON file which can be used to customize the BO4E-Schemas. The config file is optional.

  Here is a complex example of a config file:

  ```json
  {
    "nonNullableFields": [
      "bo\\.Angebot\\.angebotspreis",
      "(bo|com)\\.\\w+\\._typ",
      "\\w+\\.\\w+\\._id"
    ],
    "additionalFields": [
      {
          "pattern": "bo\\.Angebot",
          "fieldName": "foo",
          "fieldDef": {
              "type": "number"
          }
      },
      {
        "$ref": "./models/bo/Geschaeftspartner_extension.json"
      }
    ],
    "additionalEnumItems": [
      {
        "pattern": "enum\\.BoTyp",
        "items": [
          "Bilanzierung",
          "Dokument"
        ]
      }
    ],
    "additionalModels": [
      {
        "module": "bo",
        "schema": {
          "$ref": "models/bo/Bilanzierung.json"
        }
      },
      {
        "module": "bo",
        "schema": {
          "additionalProperties": true,
          "title": "Dokument",
          "type": "object",
          "description": "A generic document reference like for bills, order confirmations and cancellations",
          "properties": {
            "boTyp": {
              "allOf": [
                {
                  "$ref": "../enum/BoTyp.json#"
                }
              ],
              "title": "BoTyp",
              "default": "Dokument"
            },
            "erstellungsdatum": {
              "format": "date-time",
              "title": "Erstellungsdatum",
              "type": "string"
            }
          },
          "required": [
            "erstellungsdatum"
          ]
        }
      }
    ]
  }
  ```

  The config file can contain the following keys:
  - `nonNullabelFields`: A list of regex patterns which will be used to define non-nullable fields.
    The field will be required if the default value was `null`, which will be mostly the case.
    The regex pattern will be (full-)matched to the path of each the field.
    An example of such a path would be `bo.Angebot.angebotspreis`. If the pattern matches, the field will be non-nullable.
  - `additionalFields`: A list of additional fields which will be added to the schema.
    - `pattern`: A regex pattern which will be used to match the path of the schema (e.g. `bo.Angebot`).
      The field will be added to each schema to which the pattern matches.
    - `fieldName`: The name of the field which will be added.
    - `fieldDef`: The definition of the field which will be added.
  - `additionalEnumItems`: A list of additional enum items which will be added to the schema.
    - `pattern`: A regex pattern which will be used to match the path of the enum (e.g. `enum.BoTyp`).
      The items will be added to each enum to which the pattern matches.
    - `items`: A list of items which will be added to the enum.
  - `additionalModels`: A list of additional models which will be added to the schema.
    - `module`: The module to which the schema will be added.
    - `schema`: The schema definition which will be added.

  Note: For all config keys (except `requiredFields`), you can alternatively use the `"$ref"` key to reference to a file.
  This is useful to keep the config file small and to reuse definitions.
  If the path is relative it will be applied to the path of the directory where the config file is stored in.
  But, you can define absolute paths if you want.

  As a little extra feature for `additionalFields`: If you want to define multiple fields in one external file,
  you can define a list of fields instead of a single field. The reference in the `"$ref"` key is the same.

  Example of `./models/bo/Geschaeftspartner_extension.json`:
  ```json
  [
    {
      "pattern": "bo\\.Geschaeftspartner",
      "field_name": "foo",
      "field_def": {
        "type": "number"
      }
    },
    {
      "pattern": "bo\\.Geschaeftspartner",
      "field_name": "bar",
      "field_def": {
        "type": "string"
      }
    }
  ]
  ```



  The schemas from the repository `BO4E-Schemas` contain online references to each other
  (e.g. `"$ref": "https://raw.githubusercontent.com/BO4E/BO4E-Schemas/v202401.0.1/src/bo4e_schemas/bo/Angebot.json#"`).
  This is not very convenient if you want to work with the schemas offline. And if you need to edit the schemas using
  the config file, this would be a problem.

  To solve this problem, you can use the `--update-refs` flag. This will replace the online references with
  relative paths. It will also try to replace references introduced by the config file. But note that if the
  software can't match the reference to the pattern of an online reference, it will not replace it but instead
  log a warning.



  All BO4E-Schemas contain a field `_version` which defines the used BO4E version. All schemas which are pulled
  from the repository `BO4E-Schemas` will have the `_version` fields default value set to the respective version.
  But if you introduce additional models, it might be a bit cumbersome to set the `_version` field to the correct
  version each time you upgrade the BO4E version.

  To solve this problem, you can use the `--set-default-version` flag. It will automatically set or override the default
  value for `_version` fields with the `--target-version`.



  If you have problems with the rate limit of the GitHub API, you can specify a GitHub Access token with the
  `--token` flag. For more information, please refer to the
  [GitHub documentation](https://docs.github.com/de/rest/using-the-rest-api/rate-limits-for-the-rest-api).

  If you don't want to specify the token in the parameter list, you can also set the environment variable
  `GITHUB_ACCESS_TOKEN`.



  If you want to pull the schemas into a directory which already contains schemas, you can use the `--clear-output` flag.
  This will clear the output directory entirely before saving the schemas. This is useful if a new version of the schemas
  doesn't contain some schemas anymore which were present in the previous version.



  If you specify a cache directory with the `--cache-dir` flag, the tool will cache the raw schema files downloaded from
  GitHub. This cache is version specific and will be overridden if you want to download another version.
  This is useful if you want to execute the tool multiple times with the same version. It will save you some time during
  development.



  Follow the instructions in our [Python template repository](https://github.com/Hochfrequenz/python_template_repository#how-to-use-this-repository-on-your-machine).



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



  - Dependabot auto-approve / -merge:
    - If the actor is the Dependabot bot (i.e. on every commit by Dependabot)
      the pull request is automatically approved and auto merge gets activated
      (using squash merge).


pkgId: 2f952ea29df1d08772e936e92eec8ac6f6ee9fb1c26a018ef8612ad8e1aa6b70
name: python-BONO
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Librería para análisis y cálculos de bonos financieros
url: https://github.com/LuisHCalderon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BONO-1.1.3-1.src.rpm
checksum_type: sha256
description:
  A Python library for performing calculations and analyses related to financial bonds. Ideal for financial analysts, finance students, and developers interested in financial engineering.


  * Basic bond valuation (coupon and zero-coupon bonds).
  * Calculating bond sensitivity (Macaulay duration).
  * Yield to Maturity (YTM) calculation.
  * Generating cash flows for bonds.
  * Portfolio analysis (total value and weighted average duration).
  * Yield curve analysis.


  Calculate the price of bonds, including coupon bonds and zero-coupon bonds.

  **Example: Valuing a bond**

  ```python
  from bonos.valuacion import precio_bono
  ```
  *#Inputs: Face value (nominal value), coupon rate, discount rate, periods, payment frequency*
  ```python
  bond_price = precio_bono(valor_nominal=1000, tasa_cupon=5, tasa_descuento=3, periodos=5, frecuencia=1)
  print(f"The bond price is: {bond_price}")
  ```

  **Example: Valuing a zero-coupon bond**

  ```python
  from bonos.valuacion import precio_bono
  ```

  *#Zero-coupon bond: coupon rate = 0*
  ```python
  zero_coupon_price = precio_bono(valor_nominal=1000, tasa_cupon=0, tasa_descuento=4, periodos=10, frecuencia=1)
  print(f"The zero-coupon bond price is: {zero_coupon_price}")
  ```


  Calculate the Macaulay Duration, a measure of a bondâ€™s sensitivity to interest rate changes.

  **Example: Calculating Macaulay Duration**

  ```python
  from bonos.sensibilidad import duracion_macaulay
  ```

  *#Inputs: Face value, coupon rate, discount rate, periods, payment frequency*
  ```python
  duration = duracion_macaulay(valor_nominal=1000, tasa_cupon=5, tasa_descuento=3, periodos=5, frecuencia=1)
  print(f"The Macaulay duration is: {duration}")
  ```
  **Example: Duration of a zero-coupon bond**
  ```python
  from bonos.sensibilidad import duracion_macaulay
  ```
  *#Zero-coupon bond: coupon rate = 0*
  ```python
  zero_coupon_duration = duracion_macaulay(valor_nominal=1000, tasa_cupon=0, tasa_descuento=4, periodos=10, frecuencia=1)
  print(f"The duration of the zero-coupon bond is: {zero_coupon_duration}")
  ```


  Calculate the Yield to Maturity (YTM), which represents the bond's expected annual return if held until maturity.

  **Example: Calculating YTM**
  ```python
  from bonos.tasas import rendimiento_vencimiento
  ```
  *#Inputs: Bond price, face value, coupon rate, periods, payment frequency*
  ```python
  ytm = rendimiento_vencimiento(precio_bono=950, valor_nominal=1000, tasa_cupon=5, periodos=10, frecuencia=1)
  print(f"The yield to maturity (YTM) is: {ytm}%")
  ```

  **Example: YTM with semi-annual payments**
  ```python
  from bonos.tasas import rendimiento_vencimiento
  ```
  *#Semi-annual payments: frequency = 2*
  ```python
  ytm_semi_annual = rendimiento_vencimiento(precio_bono=950, valor_nominal=1000, tasa_cupon=5, periodos=10, frecuencia=2)
  print(f"The semi-annual yield to maturity (YTM) is: {ytm_semi_annual}%")
  ```


  Generate the cash flows of a bond, including periodic coupon payments and the redemption of the face value.

  **Example: Generating cash flows**
  ```python
  from bonos.flujos import generar_flujos
  ```
  *#Inputs: Face value, coupon rate, periods, payment frequency*
  ```python
  cash_flows = generar_flujos(valor_nominal=1000, tasa_cupon=5, periodos=5, frecuencia=2)
  print(f"Cash flows: {cash_flows}")
  ```
  **Example: Cash flows for a zero-coupon bond**
  ```python
  from bonos.flujos import generar_flujos
  ```
  *#Zero-coupon bond: coupon rate = 0*
  ```python
  zero_coupon_flows = generar_flujos(valor_nominal=1000, tasa_cupon=0, periodos=10, frecuencia=1)
  print(f"Cash flows for zero-coupon bond: {zero_coupon_flows}")
  ```


  Combine the library's features to analyze a portfolio of bonds. For instance, calculate the total portfolio value and its weighted average duration.

  **Example: Portfolio Analysis**
  ```python
  from bonos.valuacion import precio_bono
  from bonos.sensibilidad import duracion_macaulay
  ```
  *#Define portfolio bonds*
  ```python
  bonds = [
      {"valor_nominal": 1000, "tasa_cupon": 5, "tasa_descuento": 3, "periodos": 5, "frecuencia": 1},
      {"valor_nominal": 2000, "tasa_cupon": 4, "tasa_descuento": 3.5, "periodos": 10, "frecuencia": 2},
      {"valor_nominal": 1500, "tasa_cupon": 6, "tasa_descuento": 4, "periodos": 7, "frecuencia": 1},
  ]
  ```
  *#Calculate the price and duration for each bond*
  ```python
  portfolio_value = 0
  weighted_durations = 0
  for bond in bonds:
      
      price = precio_bono(
          valor_nominal=bond["valor_nominal"],
          tasa_cupon=bond["tasa_cupon"],
          tasa_descuento=bond["tasa_descuento"],
          periodos=bond["periodos"],
          frecuencia=bond["frecuencia"]
      )
      
      duration = duracion_macaulay(
          valor_nominal=bond["valor_nominal"],
          tasa_cupon=bond["tasa_cupon"],
          tasa_descuento=bond["tasa_descuento"],
          periodos=bond["periodos"],
          frecuencia=bond["frecuencia"]
      )
      
      portfolio_value += price
      weighted_durations += price * duration
  ```
  *#Calculate weighted average duration*
  ```python
  weighted_average_duration = weighted_durations / portfolio_value

  print(f"Total portfolio value: {portfolio_value}")
  print(f"Weighted average duration: {weighted_average_duration}")
  ```


  You can use the library to analyze the yield curve of bonds with different maturities, calculating their YTMs and plotting the curve.

  **Example: Yield Curve Analysis**
  ```python
  from bonos.tasas import rendimiento_vencimiento
  import matplotlib.pyplot as plt
  ```
  *#Define a series of bonds with different maturities and prices*
  ```python
  bonds = [
      {"precio_bono": 980, "valor_nominal": 1000, "tasa_cupon": 3, "periodos": 2, "frecuencia": 1},
      {"precio_bono": 950, "valor_nominal": 1000, "tasa_cupon": 4, "periodos": 5, "frecuencia": 1},
      {"precio_bono": 920, "valor_nominal": 1000, "tasa_cupon": 5, "periodos": 10, "frecuencia": 1},
      {"precio_bono": 890, "valor_nominal": 1000, "tasa_cupon": 6, "periodos": 20, "frecuencia": 1},
  ]
  ```
  *#Calculate YTM for each bond and store maturities and YTMs*
  ```python
  maturities = []
  ytms = []
  for bond in bonds:
      ytm = rendimiento_vencimiento(
          precio_bono=bond["precio_bono"],
          valor_nominal=bond["valor_nominal"],
          tasa_cupon=bond["tasa_cupon"],
          periodos=bond["periodos"],
          frecuencia=bond["frecuencia"]
      )
      maturities.append(bond["periodos"])
      ytms.append(ytm)
  ```
  *#Plot the yield curve*
  ```python
  plt.plot(maturities, ytms, marker='o')
  plt.title("Bond Yield Curve")
  plt.xlabel("Maturity (Years)")
  plt.ylabel("Yield to Maturity (YTM)")
  plt.grid()
  plt.show()
  ```


  This project is licensed under the MIT License.<p>
  ```python
  Luis Humberto Calderon B.
  UNIVERSIDAD NACIONAL DE INGENIERIA
  Lima-Peru, 2024
  ```


pkgId: 08c67d0bb722a8c4e74eb1fa46137949792e57b823744038ec4ca6615d90d629
name: python-BOOK-NLP-fr
arch: src
version: 10000.100.19
epoch: 0
release: 1
summary: BOOK_NLP_fr
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BOOK-NLP-fr-10000.100.19-1.src.rpm
checksum_type: sha256
description:
  This is a simple example package. You can use
  [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.


pkgId: a417e93cba56b41e1b5eb5862aa7b82ca0c4e198de8c582f89866292ffa2326a
name: python-BRACoD
arch: src
version: 0.3.6
epoch: 0
release: 1
url: https://github.com/ajverster/BRACoD/tree/main
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BRACoD-0.3.6-1.src.rpm
checksum_type: sha256
summary:
  BRACoD is a method to identify associations between bacteria and physiological variables in Microbiome data

description:
  Installation in python:

      pip install BRACoD

  There is also an R interface, which depends on the python version being installed. There is a helper function that will do it for you, but it might be easier to do it with pip. You can install via CRAN.

      install.packages("BRACoD.R")

  Or you can install via github.

      devtools::install_github("ajverster/BRACoD/BRACoD.R")



  1. Simulate some data and normalize it

      ```python
      import BRACoD
      import numpy as np
      sim_counts, sim_y, contributions = BRACoD.simulate_microbiome_counts(BRACoD.df_counts_obesity)
      sim_relab = BRACoD.scale_counts(sim_counts)
      ```

  2. Run BRACoD

      ```python
      trace = BRACoD.run_bracod(sim_relab, sim_y, n_sample = 1000, n_burn=1000, njobs=4)
      ```

  3. Examine the diagnostics

      ```python
      BRACoD.convergence_tests(trace, sim_relab)
      ```

  4. Examine the results

      ```python
      df_results = BRACoD.summarize_trace(trace, sim_counts.columns, 0.3)
      ```

  5. Compare the results to the simulated truth

      ```python
      taxon_identified = df_results["taxon_num"].values
      taxon_actual = np.where(contributions != 0)[0]

      precision, recall, f1 = BRACoD.score(taxon_identified, taxon_actual)
      print("Precision: {}, Recall: {}, F1: {}".format(precision, recall, f1))
      ```

  6. Try with your real data. We have included some functions to help you threshold and process your data

      ```python
      df_counts = BRACoD.threshold_count_data(BRACoD.df_counts_obesity)
      df_rel = BRACoD.scale_counts(df_counts)
      df_rel, Y = BRACoD.remove_null(df_rel, BRACoD.df_scfa_obesity["butyric"].values)
      trace = BRACoD.run_bracod(df_rel, Y, n_sample = 1000, n_burn=1000, njobs=4)
      df_results = BRACoD.summarize_trace(trace, df_rel.columns, 0.3)
      ```

  The taxonomy information for these OTUs is available at ```BRACoD.df_taxonomy```



  1. Simulate some data and normalize it

      ```R
      library('BRACoD.R')
      data(obesity)
      r <- simulate_microbiome_counts(df_counts_obesity)

      sim_counts <- r$sim_counts
      sim_y <- r$sim_y
      contributions <- r$contributions
      sim_relab <- scale_counts(sim_counts)
      ```

  2. Run BRACoD

      ```R
      trace <- run_bracod(sim_relab, sim_y, n_sample = 1000, n_burn=1000, njobs=4)
      ```

  3. Examine the diagnostics

      ```R
      convergence_tests(trace, sim_relab)
      ```

  4. Examine the results

      ```R
      df_results <- summarize_trace(trace, colnames(sim_counts))
      ```

  5. Compare the results to the simulated truth

      ```R
      taxon_identified <- df_results$taxon_num
      taxon_actual <- which(contributions != 0)

      r <- score(taxon_identified, taxon_actual)

      print(sprintf("Precision: %.2f, Recall: %.2f, F1: %.2f", r$precision, r$recall, r$f1))
      ```

  6. Try with your real data. We have included some functions to help you threshold and process your data

      ```R
      df_counts_obesity_sub <- threshold_count_data(df_counts_obesity)
      df_rel <- scale_counts(df_counts_obesity_sub)
      r <- remove_null(df_rel, df_scfa$butyric)
      df_rel <- r$df_rel
      Y <- r$Y

      trace <- run_bracod(df_rel, Y, n_sample = 1000, n_burn=1000, njobs=4)
      df_results <- summarize_trace(trace, colnames(df_counts_obesity_sub), 0.3)
      ```


pkgId: 41aca5973332df09460390ac38f55bf1b85510707fcb34513c6812220c653d88
name: python-BRAD-Chat
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: This package connects large language models with bioinformatics workflows.
url: https://pypi.org/project/BRAD-Chat/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BRAD-Chat-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Please see the projects main page available [here!](https://brad-bioinformatics-retrieval-augmented-data.readthedocs.io/_/downloads/en/latest/pdf/)



  <div align="center">
    <img width="635" alt="brad-dl-vision" src="https://github.com/user-attachments/assets/da7a1722-28ca-44e8-b45f-4350b7b29305">
  </div>



  Brad can be installed directly from pip
  <br>



  BRAD can be deployed as a web server to interact and experiment with its functionalities.

  The BRAD web server is written with react.js for the frontend and flask backend.

  The recommended method is to use docker.

  <br>


  The Docker build can be used to deploy brad without having to install packages manually.
  after installing either docker desktop or docker engine [docker intsallation](https://docs.docker.com/desktop/), you can follow one of the following commands to install and run BRAD


  1. Use with docker compose:
  ```
  cd deployment
  docker compose up -d
  ```

  2. OR with just docker

  ```
  docker run -e OPENAI_API_KEY=your_open_ai_key -e  PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS='True' -p 5001:5000 -p 3000:3000  brad:full_frontend
  ```

  3. To build the dockerfile yourself:

  ```
  docker build -t brad:local .
  ```

  Then proceed to http://localhost:3000 to view the frontend
  <br>
  <br>



  To contribute or make your own modifications to BRAD, A separate development environment needs to be set up. Follow the instructions below to set up your environment

  Download the BRAD repository
  ```
  git clone https://github.com/Jpickard1/BRAD.git
  cd BRAD
  ```
  <br>

  Update ./BRAD/config/config.json to your preference
  ( specifically update the log_path key to point somewhere on your local system )
  <br>

  Make sure python is installed and then install the requirements
  >Our recommendation is to use conda and setup a separate conda environment to ensure package discrepencies

  ```
  pip install -r requirements_frozen.txt
  ```
  <br>

  Install node=v20.18.0 and npm=10.8.2 from the (website)[https://nodejs.org/en/download/package-manager]  or by using nvm
  >Our recommendation is to use nvm
  ```
  https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
  source ~/.nvm/nvm.sh \
  nvm install 20.18.0 \
  nvm use 20.18.0


  npm install --prefix ./brad-chat
  ```

  Start BRAD backend with
  ```
  PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS=True OPENAI_API_KEY=<your_open_api_key> flask --app app run --host=0.0.0.0 --port=5000
  ```

  Start BRAD frontend with
  ```
  cd brad-chat
  npm start
  ```

  This will start BRAD Backend at - http://localhost:3000
  And the BRAD frontend at - http://localhost:5000

  <br>
  <br>



  To build the projects documentation in the ReadTheDocs html formatting, in the `docs/` directory, run the command `make html`. This will populate the `docs/build/html` directory with the webpages. The `docs/build/` directory is excluded from git but *will* automatically be built when pushing to main.

  During the build, the `tutorials/` directory is automatically pulled in to the source by copying all jupyter notebooks. These are included in the user guide section of the documentation.

  To remove the documentation from `docs/build/` run `make clean` from the same directory where you built it.

  <br>



  ```
  @article{pickard2024bioinformatics,
    title={Language Model Powered Digital Biology},
    author={Pickard, Joshua and Choi, Marc Andrew and Oliven, Natalie and
            Stansbury, Cooper and Cwycyshyn, Jillian and Galioto, Nicholas
            and Gorodetsky, Alex and Velasquez, Alvaro and Rajapakse, Indika},
    journal={arXiv preprint arXiv:2409.02864},
    url={https://arxiv.org/abs/2409.02864},
    year={2024}
  }
  ```


pkgId: 149574a1e52864d59654eefae07d669943b90c65c3f6bdf418a7c1c2e8cf8669
name: python-BRAD-Chat
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: This package connects large language models with bioinformatics workflows.
url: https://pypi.org/project/BRAD-Chat/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BRAD-Chat-0.0.4-1.src.rpm
checksum_type: sha256
description:
  - **GUI Tutorial**
    A simple tutorial for how to use BRAD's Graphical User Interface.
  - [**Hello World**](https://github.com/Jpickard1/BRAD-Examples/blob/main/Hello-World/Example-0.ipynb)
    A simple "Hello, World!" example to help you understand the basics of using the BRAD chatbot.
  - [**Search and Retrieval-Augmented Generation (RAG)**](https://github.com/Jpickard1/BRAD-Examples/blob/main/RAG-SCRAPE/Example-1.ipynb)
    Demonstrates how to use BRAD to scrape online data and integrate it into a Retrieval-Augmented Generation pipeline.
  - [**Using the Scanpy Package with BRAD**](https://github.com/Jpickard1/BRAD-Examples/blob/main/Scanpy/Example-2.ipynb)
    Explores how BRAD can streamline workflows involving **Scanpy**, including preprocessing and visualization of single-cell data.
  - [**Biomarker Selection Pipeline**](https://github.com/Jpickard1/BRAD-Examples/blob/main/DMD-Biomarkers/Example-3.ipynb)
    Illustrates how BRAD can assist in selecting biomarkers from datasets using machine learning and bioinformatics tools.


  The Docker build can be used to deploy brad without having to install packages manually.
  after installing either docker desktop or docker engine [docker intsallation](https://docs.docker.com/desktop/), you can follow one of the following commands to install and run BRAD
  1. Use with docker compose:
  ```
  cd deployment
  docker compose up -d
  ```
  2. OR with just docker
  ```
  docker run -e OPENAI_API_KEY=your_open_ai_key -e  PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS='True' -p 5001:5000 -p 3000:3000  brad:full_frontend
  ```
  3. To build the dockerfile yourself:
  ```
  docker build -t brad:local .
  ```
  Then proceed to http://localhost:3000 to view the frontend
  <br>
  <br>

  To contribute or make your own modifications to BRAD, A separate development environment needs to be set up. Follow the instructions below to set up your environment
  Download the BRAD repository
  ```
  git clone https://github.com/Jpickard1/BRAD.git
  cd BRAD
  ```
  <br>
  Update ./BRAD/config/config.json to your preference
  ( specifically update the log_path key to point somewhere on your local system )
  <br>
  Make sure python is installed and then install the requirements
  >Our recommendation is to use conda and setup a separate conda environment to ensure package discrepencies
  ```
  pip install -r requirements_frozen.txt
  ```
  <br>
  Install node=v20.18.0 and npm=10.8.2 from the (website)[https://nodejs.org/en/download/package-manager]  or by using nvm
  >Our recommendation is to use nvm
  ```
  https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
  source ~/.nvm/nvm.sh \
  nvm install 20.18.0 \
  nvm use 20.18.0

  npm install --prefix ./brad-chat
  ```
  Start BRAD backend with
  ```
  PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS=True OPENAI_API_KEY=<your_open_api_key> flask --app app run --host=0.0.0.0 --port=5000
  ```
  Start BRAD frontend with
  ```
  cd brad-chat
  npm start
  ```
  This will start BRAD Backend at - http://localhost:3000
  And the BRAD frontend at - http://localhost:5000
  <br>
  <br>

  To build the projects documentation in the ReadTheDocs html formatting, in the `docs/` directory, run the command `make html`. This will populate the `docs/build/html` directory with the webpages. The `docs/build/` directory is excluded from git but *will* automatically be built when pushing to main.
  During the build, the `tutorials/` directory is automatically pulled in to the source by copying all jupyter notebooks. These are included in the user guide section of the documentation.
  To remove the documentation from `docs/build/` run `make clean` from the same directory where you built it.
  <br>

  ```
  @article{pickard2024bioinformatics,
    title={Language Model Powered Digital Biology},
    author={Pickard, Joshua and Choi, Marc Andrew and Oliven, Natalie and
            Stansbury, Cooper and Cwycyshyn, Jillian and Galioto, Nicholas
            and Gorodetsky, Alex and Velasquez, Alvaro and Rajapakse, Indika},
    journal={arXiv preprint arXiv:2409.02864},
    url={https://arxiv.org/abs/2409.02864},
    year={2024}
  }
  ```


pkgId: 2799b459a700d54080e14aa6f30b4d7ccc2cfaf17940f1c340fc12de75a650eb
name: python-BRAILS
arch: src
version: 3.1.3
epoch: 0
release: 1
summary: Building and Infrastructure Recognition Using AI at Large-Scale
url: https://github.com/NHERI-SimCenter/BRAILS
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BRAILS-3.1.3-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/184673734.svg)](https://zenodo.org/badge/latestdoi/184673734)
  [![PyPi version](https://badgen.net/pypi/v/BRAILS/)](https://pypi.org/project/BRAILS/)
  [![PyPI download month](https://img.shields.io/pypi/dm/BRAILS.svg)](https://pypi.python.org/pypi/BRAILS/)



  BRAILS (Building and Infrastructure Recognition using AI at Large-Scale) provides a set of Python modules that utilize deep learning (DL), and computer vision (CV) techniques to extract information from satellite and street level images. The BRAILS framework also provides turn-key applications allowing users to put individual modules together to determine multiple attributes in a single pass or train general-purpose image classification, object detection, or semantic segmentation models.



  Online documentation is available at <a href="https://nheri-simcenter.github.io/BRAILS-Documentation/index.html">https://nheri-simcenter.github.io/BRAILS-Documentation</a>.






  The easiest way to install the latest version of BRAILS is using ``pip``:
  ```
  pip install BRAILS
  ```



  This example demonstrates how to use the ``InventoryGenerator`` method embedded in BRAILS to generate regional-level inventories.

  The primary input to ``InventoryGenerator`` is location. ``InventoryGenerator`` accepts four different ``location`` input types: 1) region name, 2) list of region names, 3) a tuple containing the coordinates for two opposite vertices of a bounding box for a region (e.g., ``(vert1lon,vert1lat,vert2lon,vert2lat)``), and a 4) GeoJSON file containing building footprints or location points.

  InventoryGenerator automatically detects building locations in a region by downloading footprint data for the ``location`` input. The three footprint data sources, ``fpSource``, included in BRAILS are i) OpenStreetMaps, ii) Microsoft Global Building Footprints dataset, and iii) FEMA USA Structures. The keywords for these sources are ``osm``, ``ms``, and ``usastr``, respectively.

  ``InventoryGenerator`` also allows inventory data to be imported from the National Structure Inventory or another user-specified file to create a baseline building inventory.

  Please note that to run the ``generate`` method of ``InventoryGenerator``, you will need a Google API Key.

  ```python

  from brails.InventoryGenerator import InventoryGenerator


  invGenerator = InventoryGenerator(location='Berkeley, CA',
                                    fpSource='usastr',
                                    baselineInv='nsi',
                                    lengthUnit='m',
                                    outputFile='BaselineInvBerkeleyCA.geojson')


  invGenerator.enabled_attributes()



  invGenerator.generate(attributes=['numstories','roofshape','buildingheight'],
                        GoogleAPIKey='ENTER-YOUR-API-KEY-HERE',
                        nbldgs=100,
                        outputFile='BldgInvBerkeleyCA.geojson')


  invGenerator.inventory

  ```



  This work is based on material supported by the National Science Foundation under grants CMMI 1612843 and CMMI 2131111.




  NHERI-SimCenter nheri-simcenter@berkeley.edu



  ```
  @software{cetiner_2024_10448047,
    author       = {Barbaros Cetiner and
                    Charles Wang and
                    Frank McKenna and
                    Sascha Hornauer and
                    Jinyan Zhao and
                    Yunhui Guo and
                    Stella X. Yu and
                    Ertugrul Taciroglu and
                    Kincho H. Law},
    title        = {BRAILS Release v3.1.1},
    month        = feb,
    year         = 2024,
    publisher    = {Zenodo},
    version      = {v3.1.1},
    doi          = {10.5281/zenodo.10606032},
    url          = {https://doi.org/10.5281/zenodo.10606032}
  }
  ```


pkgId: 40b865196ff58c02c2f52ac85f7dd9fe01abd803ac9e9b3e2c097a5c49b667f7
name: python-BSTPythonSDK
arch: src
version: 3.21.0.dev11
epoch: 0
release: 1
summary: BST Flight Management SDK
url: https://github.com/bstaero/sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BSTPythonSDK-3.21.0.dev11-1.src.rpm
checksum_type: sha256
description:
  This is the public SDK for the Black Swift Technologies SwiftCore flight management system.  More information on the products this works with can be found on our website https://bst.aero

  For information on using this with a gazebo multi-rotor simulation, see here: https://gitlab.com/bstaero/sdk/-/wikis/gazebo-setup

  For information interfacing with the BST SwiftFlow wind probe, see here: https://gitlab.com/bstaero/sdk/-/wikis/swiftflow-interface


pkgId: 8dba76c8d31d7acf848989a063a8eed1d214e888b8a51ab51a448bb2f2e82b57
name: python-BTEdb
arch: src
version: 7.0.1
epoch: 0
release: 1
summary: Python schemaless JSON/YAML database interface
url: http://github.com/nilesr/BTEdb
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BTEdb-7.0.1-1.src.rpm
checksum_type: sha256
description:
  BTEdb (Better Than Ethan's database) is a project created because Ethan thought he could write a database in Python, and mine has to be better than his

  It is a schemaless database like MongoDB that serializes to JSON. It can either serialize to a file, or an object that you pass it.

  An example:

      db = BTEdb.Database("filename.json")

  Or:

      class MyClass:
          def seek(self,position,mode):
              pass
          def truncate(self):
              return False
          def __init__(self):
              self.data = ""
          def write(self,data):
              self.data = data
          def flush(self):
              pass
          def read(self):
              return self.data
          def close(self):
              pass
      MyObject = MyClass()
      db = BTEdb.Database(MyObject)

  You don't need to specify an object at all when initiating a database, but you will still need to create one. For example:

      db = BTEdb.Database("filename.json")

  does the same thing as:

      db = BTEdb.Database()
      db.OpenDatabase("filename.json")

  This allows you to switch files on-the-fly

  BTEdb also supports pretty-print. Specify any number of spaces for the database to use, for example:

      db = BTEdb.Database("filename.json", 4)

  or:

      db = BTEdb.Database()
      db.OpenDatabase("filename.json", 4)


  You can safely close file descriptors and return the database to a just-created state like this:

      db.Destroy()

  Creating a table looks like this:

      db.Create("Table name")

  If the table exists, it will be truncated

  If the table does not exist, most of the following methods will raise a TableDoesNotExistException

  Drop the bass:

      db.Drop("Table name")

  Truncate a table like this:

      db.Truncate("Table name")

  Dump the entire database:

      db.Dump()

  Or a specific table:

      db.Dump("Table name")

  Check if a table exists like this:

      db.TableExists("Table name")

  Insert like this:

      db.Insert("Table name", Username = "Niles", UID = 1000, favColour = 0xffffff)

  As with all schemaless databases, you are responsible for sanitizing the input and output to the database. It is entirely possible to store that entry and {x = 12, y = 24, pointColour = "green"} in the same table.

  Select data like this:

      db.Select("Table name", UID = 1000)

  This selects all entries with the UID of 1000 and the favourite colour of white:

      db.Select("Table name", UID = 1000, favColour = 0xffffff)

  This selects all entries with the favourite colour of white and who has an E in their username, case insensitive:

      db.Select("Table name", favColour = 0xffffff, lambda x: "e" in x["username"].lower())

  You may use a lambda or a pre-defined function. For example:

      import urllib2
  	def CheckUser(Datapoint):
  		values = { "UID" : Datapoint["UID"], "username" : Datapoint["username"] }
  		postdata = urllib2.encode(values)
  		request = urllib2.Request("http://example.com/CheckUser.php",postdata)
  		response = request.read()
  		if response == "User accepted":
  			return True
  		else:
  			return False
  	db.Select("Table name", CheckUser)

  That would query an external server to check the username and UID to determine if each row should be selected or not. Be warned that this will generate a LOT of network traffic

  Deleting is similar. The following will delete any user with the UID of 1000:

      db.Delete("Table name", UID = 1000)

  Lambdas and functions may also be used here.

  It is important to note that the first non-keyword argument is the table name. Non-function or lambda non-keyword arguments after the table name will raise a TypeError

  Update is a little bit more complicated. Here is an example to get you going

      db.Update("Table name", db.Select("Table name", favColour = 0xffffff), UID = 12, Username = "test")

  This is the same as the SQL statement:

      UPDATE `Table name` SET `UID` = 12, `Username` = 'test' WHERE `favColour` = 0xffffff;

  Lambdas may be used in the select statement, but not the update statement. To achieve something similar, you can do this:

      for x in db.Select("Table name", favColour = 0xffffff):
          db.Update("Table name", [x], UID = x["UID"] + 1)

  That would increment the UIDs of every user with the favourite colour of white.

  It can also be combined with the Dump method

      db.Update("Table name", db.Dump("Table name"), username = "newusername")

  That would change every user's username to "newusername"

  Saving a savepoint is as easy as this:

      db.Save("Savepoint name")

  Reverting back to a savepoint:

      db.Revert("Savepoint name")

  Saving a specific table:

  	db.Save("Savepoint name", "Table name")

  Recovering a specific table from a savepoint:

      db.Revert("Savepoint name", "Table name")

  Deleting a savepoint

  	db.RemoveSave("Savepoint name")

  If you only saved a few tables, only those tables will be recovered if you attempt to recover the entire save.

  You can manually retrieve or insert a savepoint with these methods:

      db.GetSave("Savepoint name")
  	db.GetSave()
      db.PutSave(data,"Savepoint name")
  	db.PutSave(data)

  Under most circumstances, you should never need to use those methods. If for some reason you do, DO NOT confuse whether you are putting a save requested with a savepoint name or without one.

  Triggers are identified by name, which can be a string, integer, float, or a few other datatypes. The name must be unique, however you may have infinite triggers.

  You can add a trigger something like this:

      import time
      def handler(db, datapoint, table, event):
  		print("Handler being called on event " + event + " on datapoint " + str(datapoint) + " in table " + table)
  		db.Save(str(time.time()),table)
      db.AddTrigger("Trigger Name", "AFTER UPDATE", "Table name", handler)

  That will make any update to something in the "Table name" table print a message and make a new savepoint. Beware that this will run for each individual datapoint.

  You may also use lambda expressions.

  Valid events are "BEFORE INSERT", "AFTER INSERT", "BEFORE DELETE", "AFTER DELETE", "BEFORE UPDATE" and "AFTER UPDATE"

  With INSERT and DELETE, the same datapoint is passed to both BEFORE and AFTER handlers. With UPDATE, the old and new datapoints are passed to the BEFORE and AFTER handlers, respectively.

  Remove like this:

      db.RemoveTrigger("Trigger name")

  You may have multiple handlers for a single event.

  Transactions are necessary for an efficient database.

  While not inside a transaction, methods that modify the database write out the database to the disk before they return. This is good if you don't have a lot of requests, but if you are going to execute two or more statements that modify data in a row, you should execute them within a transaction.

  Begin a transaction like this:

  	db.BeginTransaction()

  However, that will create a savepoint called "transaction". To begin a transaction without that, (you will be unable to revert the transaction) do this:

  	db.BeginTransaction(False)

  To commit the transaction and write to the disk:

  	db.CommitTransaction()

  If you chose to make a save, you can revert a transaction:

  	db.RevertTransaction()

  You can always tell if a transaction is in progress with the boolean value ``db.TransactionInProgress``

  Other less used methods:

      db.Vacuum()                 # Forces a write to the disk
  	db.ListSaves()              # Lists savepoints
      db.ListTables()             # Guess
  	db.ListTriggers()           # Figure it out yourself
  	db.TriggerExists(name)      # Who even reads these


pkgId: 5cbe73df68fab37837d34deb161b2fa20ada17911e648eb21351d88c003fd4a5
name: python-BUCTOJ
arch: src
version: 0.3.8.1
epoch: 0
release: 1
summary: 用Python玩转北化OJ平台
url: https://github.com/LetMeFly666/BUCTOJ
rpm_license: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BUCTOJ-0.3.8.1-1.src.rpm
checksum_type: sha256
description:
  将 `BUCT-OJ <https://buctcoder.com/>`_ 的一些功能封装成包，从而实现通过脚本提交代码等。
  ⚠ 仅供学习测试，不能用于特殊用途
  ⚠ 对于拥有管理员账号的同学，应该有自觉使用管理号的觉悟，不会用来免做题目
  主要供BUCTOJ管理员使用


pkgId: 70ea41ef3bbd17ed10dfd61622aa9b186d7bf3de60cf47fecc10491e8b4beeb9
name: python-BYOST
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: BYOST (Build Your Own Spectral Template)
url: https://pypi.org/project/BYOST/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BYOST-0.0.13-1.src.rpm
checksum_type: sha256
description:
  Using Pricipal Component Analysis and Gaussian Process Regression                     to construct spectral template given 2 conditions.                     see https://arxiv.org/abs/2211.05998 for details.


pkgId: 7f71013616a60979399239d29d1eef1c72e3398fb66eedc700bea507930e566c
name: python-BaSiCPy
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A python package for background and shading correction of optical microscopy images
url: https://github.com/peng-lab/BaSiCPy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BaSiCPy-1.2.0-1.src.rpm
checksum_type: sha256
description:
  See [Read the Docs](https://basicpy.readthedocs.io/en/latest/) for the detailed usage.


   Install from PyPI
  ```console
  pip install basicpy
  ```
  or install the latest development version
  ```console
  git clone https://github.com/peng-lab/BaSiCPy.git
  cd BaSiCPy
  pip install .
  ```

  BaSiCPy requires [`jax`](https://github.com/google/jax/),
  which has potential build issue with M1 chips.
  One easiest solution is using [Miniforge](https://github.com/conda-forge/miniforge)
  as explained [here](https://github.com/google/jax/issues/5501).
  In the Miniforge environment, please try the following:
  ```bash
  conda install -c conda-forge jax jaxlib
  pip install basicpy
  ```

  BaSiCPy requires [`jax`](https://github.com/google/jax/) which does not support Windows officially.
  However, thanks to [cloudhan/jax-windows-builder](https://github.com/cloudhan/jax-windows-builder), we can install BaSiCPy as follows:
  ```bash
  pip install "jax[cpu]==0.4.11" -f https://whls.blob.core.windows.net/unstable/index.html --use-deprecated legacy-resolver
  pip install ml-dtypes==0.2.0
  pip install basicpy
  ```
  One may need to add
  ```python
  import jax
  jax.config.update('jax_platform_name', 'cpu')
  ```
  at the top of the script to ensure that JAX uses CPU.
  For details and latest updates, see [this issue](https://github.com/google/jax/issues/438).

  ```console
  git clone https://github.com/peng-lab/BaSiCPy.git
  cd BaSiCPy
  python -m venv venv
  source venv/bin/activate
  pip install -e '.[dev]'
  ```


  This repository uses [bump2version](https://github.com/c4urself/bump2version) to manage dependencies. New releases are pushed to PyPi in the CI pipeline when a new version is committed with a version tag and pushed to the repo.
  The development flow should use the following process:
  1. New features and bug fixes should be pushed to `dev`
  2. When tests have passed a new development version is ready to be release, use `bump2version major|minor|patch`. This will commit and create a new version tag with the `-dev` suffix.
  3. Additional fixes/features can be added to the current development release by using `bump2version build`.
  4. Once the new bugs/features have been tested and a main release is ready, use `bump2version release` to remove the `-dev` suffix.
  After creating a new tagged version, push to Github and the version will be built and pushed to PyPi.

  This repository uses [All Contributors](https://allcontributors.org/) to manage the contributor list. Please execute the following to add/update contributors.
  ```bash
  yarn
  yarn all-contributors add username contribution
  yarn all-contributors generate # to reflect the changes to README.md
  ```
  For the possible contribution types, see the [All Contributors documentation](https://allcontributors.org/docs/en/emoji-key).


  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/Nicholas-Schaub"><img src="https://avatars.githubusercontent.com/u/15925882?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Nicholas-Schaub</b></sub></a><br /><a href="#projectManagement-Nicholas-Schaub" title="Project Management">📆</a> <a href="https://github.com/peng-lab/BaSiCPy/pulls?q=is%3Apr+reviewed-by%3ANicholas-Schaub" title="Reviewed Pull Requests">👀</a> <a href="#infra-Nicholas-Schaub" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=Nicholas-Schaub" title="Tests">⚠️</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=Nicholas-Schaub" title="Code">💻</a> <a href="#ideas-Nicholas-Schaub" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://github.com/tdmorello"><img src="https://avatars.githubusercontent.com/u/34800427?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Tim Morello</b></sub></a><br /><a href="https://github.com/peng-lab/BaSiCPy/commits?author=tdmorello" title="Code">💻</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=tdmorello" title="Documentation">📖</a> <a href="https://github.com/peng-lab/BaSiCPy/pulls?q=is%3Apr+reviewed-by%3Atdmorello" title="Reviewed Pull Requests">👀</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=tdmorello" title="Tests">⚠️</a> <a href="#ideas-tdmorello" title="Ideas, Planning, & Feedback">🤔</a> <a href="#infra-tdmorello" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
      <td align="center"><a href="https://github.com/tying84"><img src="https://avatars.githubusercontent.com/u/11461947?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Tingying Peng</b></sub></a><br /><a href="#data-tying84" title="Data">🔣</a> <a href="#financial-tying84" title="Financial">💵</a> <a href="#projectManagement-tying84" title="Project Management">📆</a> <a href="#talk-tying84" title="Talks">📢</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=tying84" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/yfukai"><img src="https://avatars.githubusercontent.com/u/5919272?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Yohsuke T. Fukai</b></sub></a><br /><a href="#research-yfukai" title="Research">🔬</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=yfukai" title="Code">💻</a> <a href="#ideas-yfukai" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/peng-lab/BaSiCPy/pulls?q=is%3Apr+reviewed-by%3Ayfukai" title="Reviewed Pull Requests">👀</a> <a href="https://github.com/peng-lab/BaSiCPy/commits?author=yfukai" title="Tests">⚠️</a> <a href="#question-yfukai" title="Answering Questions">💬</a> <a href="#infra-yfukai" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
      <td align="center"><a href="https://github.com/YuLiu-web"><img src="https://avatars.githubusercontent.com/u/70626217?v=4?s=100" width="100px;" alt=""/><br /><sub><b>YuLiu-web</b></sub></a><br /><a href="https://github.com/peng-lab/BaSiCPy/commits?author=YuLiu-web" title="Documentation">📖</a> <a href="#userTesting-YuLiu-web" title="User Testing">📓</a></td>
    </tr>
  </table>
  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  For details on the contribution roles, see the [documentation](https://basicpy.readthedocs.io/en/latest/contributors.html).

  - Lorenz Lamm (@LorenzLamm)
  - Mohammad Mirkazemi (@Mirkazemi)


pkgId: 6ae403959dd6fb2bfc9e16aa5468226dfcbaaccb24a6caedcb6ff99019b6949d
name: python-BabitMF
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: Babit Multimedia Framework
url: https://github.com/BabitMF/bmf
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BabitMF-0.0.11-1.src.rpm
checksum_type: sha256
description:
  **BMF (Babit Multimedia Framework)** is a cross-platform, multi-language, customizable multimedia processing framework developed by [**ByteDance**](https://www.bytedance.com/en).
  With over 4 years of testing and improvements, BMF has been tailored to adeptly tackle challenges in our real-world production environments. It is currently widely used in ByteDance's video streaming, live transcoding, cloud editing and mobile pre/post processing scenarios. More than 2 billion videos are processed by the framework every day.

  Here are some key features of BMF:

  - **Cross-Platform Support:** Native compatibility with Linux, Windows, and Mac OS, as well as optimization for both x86 and ARM CPUs.

  - **Easy to use:** BMF provides Python, Go, and C++ APIs, allowing developers the flexibility to code in their favourite languages.

  - **Customizability:** Developers can enhance the framework's features by adding their own modules independently because of BMF decoupled architecture.

  - **High performance:** BMF has a powerful scheduler and strong support for heterogeneous acceleration hardware. Moreover, [**NVIDIA**](https://www.nvidia.com/) has been cooperating with us to develop a highly optimized GPU pipeline for video transcoding and AI inference.

  - **Efficient data conversion:** BMF offers seamless data format conversions across popular frameworks (FFmpeg/Numpy/PyTorch/OpenCV/TensorRT), conversion between hardware devices (CPU/GPU), and color space and pixel format conversion.

  Dive deeper into BMF's capabilities on our [website](https://babitmf.github.io/) for more details.


  In this section, we will directly showcase the capabilities of the BMF framework around five dimensions: **Transcode**, **Edit**, **Meeting/Broadcaster**, **GPU acceleration**, and **AI Inference**. For all the demos provided below, corresponding implementations and documentation are available on Google Colab, allowing you to experience them intuitively.


  This demo describes step-by-step how to use BMF to develop a transcoding program, including video transcoding, audio transcoding, and image transcoding. In it, you can familiarize yourself with how to use BMF and how to use FFmpeg-compatible options to achieve the capabilities you need.

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/transcode/bmf_transcode_demo.ipynb)


  The Edit Demo will show you how to implement a high-complexity audio and video editing pipeline through the BMF framework. We have implemented two Python modules, video_concat and video_overlay, and combined various atomic capabilities to construct a complex BMF Graph.

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/edit/bmf_edit_python.ipynb)


  This demo uses BMF framework to construct a simple broadcast service. The service provides an API that enables dynamic video source pulling, video layout control, audio mixing, and ultimately streaming the output to an RTMP server. This demo showcases the modularity of BMF, multi-language development, and the ability to dynamically adjust the pipeline.

  Below is a screen recording demonstrating the operation of broadcaster:

  ![](bmf/demo/broadcaster/broadcaster.gif)





  The video frame extraction acceleration demo shows:
  1. BMF flexible capability of:

     *   Multi-language programming, we can see multi-language modules work together in the demo
     *   Ability to extend easily, there are new C++, Python modules added simply
     *   FFmpeg ability is fully compatible

  2. Hardware acceleration quickly enablement and CPU/GPU pipeline support

     *   Heterogeneous pipeline is supported in BMF, such as process between CPU and GPU
     *   Useful hardware color space conversion in BMF

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/video_frame_extraction/video_frame_extraction_acceleration.ipynb)



  The GPU transcoding and filter module demo shows:
  1. Common video/image filters in BMF accelerated by GPU
  2. How to write GPU modules in BMF

  The demo builds a transcoding pipeline which fully runs on GPU:

  decode->scale->flip->rotate->crop->blur->encode

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/gpu_module/gpu_module_demo_colab.ipynb)






  This demo shows how to integrate the state of art AI algorithms into the BMF video processing pipeline. The famous open source colorization algorithm [DeOldify](https://github.com/jantic/DeOldify) is wrapped as a BMF pyhton module in less than 100 lines of codes. The final effect is illustrated below, with the original video on the left side and the colored video on the right.

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/colorization_python/deoldify_demo_colab.ipynb)

  ![](bmf/demo/colorization_python/deoldify.gif)


  This demo implements the super-resolution inference process of [Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN) as a BMF module, showcasing a BMF pipeline that combines decoding, super-resolution inference and encoding.

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/video_enhance/bmf-enhance-demo.ipynb)




  This demo shows how to invoke our aesthetic assessment model using bmf. Our deep learning model Aesmode has achieved a binary classification accuracy of 83.8% on AVA dataset, reaching the level of academic SOTA, and can be directly used to evaluate the aesthetic degree of videos by means of frame extraction processing.

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/aesthetic_assessment/aesmod_bmfv3_fin.ipynb)



  This Demo shows a full-link face detect pipeline based on TensorRT acceleration, which internally uses the TensorRT-accelerated Onnx model to process the input video. It uses the NMS algorithm to filter repeated candidate boxes to form an output, which can be used to process a Face Detection Task efficiently.

  If you want to have a quick experiment, you can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/demo/face_detect/facedetect_demo_colab.ipynb)






  - [About BMF](https://babitmf.github.io/about/)

  - [Quick Experience](#quick-experience)
    - [Transcode](#transcode)
    - [Edit](#edit)
    - [Meeting/Broadcaster](#meetingbroadcaster)
    - [GPU acceleration](#gpu-acceleration)
      - [GPU Video Frame Extraction](#gpu-video-frame-extraction)
      - [GPU Video Transcoding and Filtering](#gpu-video-transcoding-and-filtering)
    - [AI Inference](#ai-inference)
      - [Deoldify](#deoldify)
      - [Super Resolution](#super-resolution)
      - [Video Quality Score](#video-quality-score)
      - [Face Detect With TensorRT](#face-detect-with-tensorrt)

  - [Getting Started](https://babitmf.github.io/docs/bmf/getting_started_yourself/)
    - [Install](https://babitmf.github.io/docs/bmf/getting_started_yourself/install/)
    - [Create a Graph](https://babitmf.github.io/docs/bmf/getting_started_yourself/create_a_graph/)
      - one of transcode example with 3 languages
    - [Use Module Directly](https://babitmf.github.io/docs/bmf/getting_started_yourself/use_module_directly/)
      - sync mode with 3 languages. You can try it on:

        Python:[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_python.ipynb)
        C++:[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_cpp.ipynb)
        Go:[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/test/sync_mode/bmf_syncmode_go.ipynb)
    - [Create a Module](https://babitmf.github.io/docs/bmf/getting_started_yourself/create_a_module/)
      - customize module with python, C++ and Go. You can try it on [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/BabitMF/bmf/blob/master/bmf/test/customize_module/bmf_customize_demo_latest.ipynb)

  - [Multiple Features (with examples)](https://babitmf.github.io/docs/bmf/multiple_features/)
    - [Graph Mode](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/)
      - [Generator Mode](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/generatemode/)
      - [Sync Mode](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/syncmode/)
      - [Server Mode](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/servermode/)
      - [Preload Mode](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/preloadmode/)
      - [Subgraph](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/subgraphmode/)
      - [PushData Mode](https://babitmf.github.io/docs/bmf/multiple_features/graph_mode/pushdatamode/)
    - [FFmpeg Fully Compatible](https://babitmf.github.io/docs/bmf/multiple_features/ffmpeg_fully_compatible/)
    - [Data Convert Backend](https://babitmf.github.io/docs/bmf/multiple_features/data_backend/)
    - [Dynamic Graph](https://babitmf.github.io/docs/bmf/multiple_features/dynamic_graph/)
    - [GPU Hardware Acceleration](https://babitmf.github.io/docs/bmf/multiple_features/gpu_hardware_acc/)
    - [BMF Tools](https://babitmf.github.io/docs/bmf/multiple_features/tools/)

  - APIs
    - [API in Python](https://babitmf.github.io/docs/bmf/api/api_in_python/)
    - [API in Cpp](https://babitmf.github.io/docs/bmf/api/api_in_cpp/)
    - [API in Go](https://babitmf.github.io/docs/bmf/api/api_in_go/)

  - [License](#license)
  - [Contributing](#contributing)


  The project has an [Apache 2.0 License](https://github.com/BabitMF/bmf/blob/master/LICENSE). Third party components and dependencies remain under their own licenses.



  Contributions are welcomed. Please follow the
  [guidelines](https://github.com/BabitMF/bmf/blob/master/CONTRIBUTING.md).

  We use GitHub issues to track and resolve problems. If you have any questions, please feel free to join the discussion and work with us to find a solution.


  The decoder, encoder and filter reference [ffmpeg cmdline tool](http://ffmpeg.org/). They are wrapped as BMF's built-in modules under the LGPL license.

  The project also draws inspiration from other popular frameworks, such as [ffmpeg-python](https://github.com/kkroening/ffmpeg-python) and [mediapipe](https://github.com/google/mediapipe). Our [website](https://babitmf.github.io/) is using the project from [docsy](https://github.com/google/docsy) based on [hugo](https://github.com/gohugoio/hugo).

  Here, we'd like to express our sincerest thanks to the developers of the above projects!


pkgId: a9db7eedbb87c4e8ec71ab804f8da2ab777110d04beb5536ff4be949410aa1b5
name: python-Backtesting
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Backtest trading strategies in Python
url: https://kernc.github.io/backtesting.py/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Backtesting-0.3.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/github/workflow/status/kernc/backtesting.py/CI/master?style=for-the-badge)](https://github.com/kernc/backtesting.py/actions)
  [![Code Coverage](https://img.shields.io/codecov/c/gh/kernc/backtesting.py.svg?style=for-the-badge)](https://codecov.io/gh/kernc/backtesting.py)
  [![Backtesting on PyPI](https://img.shields.io/pypi/v/backtesting.svg?color=blue&style=for-the-badge)](https://pypi.org/project/backtesting)
  [![PyPI downloads](https://img.shields.io/pypi/dd/backtesting.svg?color=skyblue&style=for-the-badge)](https://pypi.org/project/backtesting)
  [![GitHub Sponsors](https://img.shields.io/github/sponsors/kernc?color=pink&style=for-the-badge)](https://github.com/sponsors/kernc)
  Backtest trading strategies with Python.
  [**Project website**](https://kernc.github.io/backtesting.py)
  [Documentation]
  [![Star](https://i.imgur.com/LSI6p6O.png)](#top) the project if you use it.
  [Documentation]: https://kernc.github.io/backtesting.py/doc/backtesting/


pkgId: fe90f5b29ea80fe1145fb21c1b19ec21c423310bbbb8f542452f35ddcdc1d2e0
name: python-BackuPy
arch: src
version: 1.10.1
epoch: 0
release: 1
summary: A simple backup program in python with an emphasis on data integrity and transparent behaviour
url: https://github.com/elesiuta/backupy
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BackuPy-1.10.1-1.src.rpm
checksum_type: sha256
description:
    - [Installation](#installation)
    - [Features](#features)
    - [Design Goals](#design-goals)
    - [Usage Description](#usage-description)
    - [Command Line Interface](#command-line-interface)
    - [Configuration File](#configuration-file)
    - [Building From Source](#building-from-source)

  - Install the latest release from PyPI (supports all platforms with Python and has no dependencies outside the standard library)
  ```
  pip install backupy --upgrade
  ```

  - Backup, Mirror, and Sync Modes
  - Compare files using attributes or CRCs
  - View changed file tree with curses
  - Detection and alerts of corrupted files
  - Detection and alerts of unexpected file modifications on destination outside of backups and mirrors, or sync conflicts (a file was modified on both sides since the last sync)
  - JSON formatted database for tracking files and CSV formatted logs
  - Filter files with regular expressions
  - Files are always safe by default, being moved to an identically structured archive directory before being deleted or overwritten

  - Backups should be future proof and verifiable, even without BackuPy
    - uses [file-based increments](https://wiki.archlinux.org/index.php/Synchronization_and_backup_programs#File-based_increments) and human readable database/log files that are also easy to parse
  - Code should be simple and easy to verify to ensure predicable and reliable operation
    - a callgraph is available in `analysis/callgraph.svg`
    - there are only three, easy to follow functions (under `FileManager` in `backupy/fileman.py`) that ever touch your files, no more, no less, three shall be the number of thou functions, and the number of the functions shall be three
    - use trustworthy dependencies
  - Follow the principle of least astonishment
    - clear backup behaviour between directories, the current status of files and how they will be handled upon execution should be perfectly obvious
  - Avoid feature creep and duplicating other programs
    - no delta-transfer (extend with another backend)
    - no network storage or FUSE support (these must be mounted by another program for BackuPy to see them)
    - no backup encryption (use encrypted storage)
    - no filesystem monitoring (this is not a continuous backup/sync program)
  - Easily extensible with other backends
    - all the low level functions used for file operations are under `FileOps` from `backupy.utils` for easy monkey patching (see `example_extension.py`)

  - Source and destination directories can be any directory accessible via the computer's file system
    - Destination can be empty or contain files from a previous backup (even one made without BackuPy), matching files on both sides will be skipped
    - Use the `--posix` flag if you plan on using BackuPy between Windows and any other OS
  - `Main modes` (how to handle new and deleted files)
    - `Backup mode:` copies files that are only in source to destination
    - `Mirror mode:` copies files that are only in source to destination and deletes files that are only in destination
    - `Sync mode:` copies files that are only in source to destination and copies files that are only in destination to source
      - you may also want to use `--sync-delete` to propagate deletions
      - see `write_database_x2` in the [configuration file](#configuration-file) if syncing more than two folders
  - `Selection modes` (which file to select in cases where different versions exist on both sides)
    - `Source mode:` copy source files to destination
    - `Destination mode:` copy destination files to source
    - `Newer mode:` copy newer files based on last modified time
    - `None mode:` don't copy either, differing files will only be logged for manual intervention
  - `Compare modes` (how to detect which files have changed)
    - `Attribute mode:` compare file attributes (size and last modified time)
    - `Attribute+ mode:` compare file attributes and calculate CRCs only for new and changed files for future verification
    - `CRC mode:` compare file attributes and CRC for every file, and checks previously stored CRCs to detect corruption
      - you may also want to use `--verify` to verify the CRC of files after they're copied
  - Test your options first with the `--dry-run` flag
  - See [Command Line Interface](#command-line-interface) and [Configuration File](#configuration-file) below for all available options
  - By default, you will always be notified of any changes, unexpected modifications, sync conflicts, or file corruption before being prompted to continue, cancel, or skip selected files
    - it is recommended to use `--qconflicts` if using `--noprompt`, especially if also using `--noarchive`
  - By default, you will be prompted before any changes are made to your files and
    - overwritten files will be moved to `<source|dest>/.backupy/Archives/yymmdd-HHMM/<original path>`
    - deleted files will be moved to `<source|dest>/.backupy/Trash/yymmdd-HHMM/<original path>`
  - Symbolic links to folders are never followed and always copied verbatim
  - Symbolic links to files are followed by default, copying the referenced file, use `--nofollow` to copy symbolic links to files verbatim
  - To restore files, just copy them over from your destination to source (or swap source and destination in BackuPy)

  ```
  usage: backupy [options] -- <source> <dest>
         backupy <source> <dest> [options]
         backupy <source> --load [-c mode] [--dbscan] [--dry-run]
         backupy -h | --help | --version

  positional arguments:
    source       Path to source
    dest         Path to destination

  optional arguments:
    -h, --help   show this help message and exit
    --version    show program's version number and exit

  file mode options:

    -m mode      Main mode: for files that exist only on one side
                   MIRROR (default)
                     [source-only -> destination, delete destination-only]
                   BACKUP
                     [source-only -> destination, keep destination-only]
                   SYNC
                     [source-only -> destination, destination-only -> source]
    -s mode      Selection mode: for files that exist on both sides but differ
                   SOURCE (default)
                     [copy source to destination]
                   DEST
                     [copy destination to source]
                   NEW
                     [copy newer to opposite side]
                   NO
                     [do nothing]
    -c mode      Compare mode: for detecting which files differ
                   ATTR (default)
                     [compare file attributes: mod-time and size]
                   ATTR+
                     [compare file attributes and record CRC for changed files]
                   CRC
                     [compare file attributes and CRC for every file]

  misc file options:

    --sync-delete
                 Use the database to propagate deletions since the last sync
    --fi regex [regex ...]
                 Filter: Only include files matching the regular expression(s)
                 (include all by default, searches file paths)
    --fe regex [regex ...]
                 Filter: Exclude files matching the regular expression(s)
                 (exclude has priority over include, searches file paths)
    --noarchive  Disable archiving files before overwriting/deleting to:
                    <source|dest>/.backupy/Archives/yymmdd-HHMM/
                    <source|dest>/.backupy/Trash/yymmdd-HHMM/
    --nofollow   Do not follow symlinks when copying files
    --nomoves    Do not detect when files are moved or renamed

  execution options:

    --noprompt   Complete run without prompting for confirmation
    -d, --dbscan
                 Only scan files to check and update their database entries
    -n, --dry-run
                 Perform a dry run with no changes made to your files
    -q, --qconflicts
                 Quit if database conflicts are detected (always notified)
                   -> unexpected changes on destination (backup and mirror)
                   -> sync conflict (file modified on both sides since last sync)
                   -> file corruption (ATTR+ or CRC compare modes)
    -v, --verify
                 Verify CRC of copied files

  backend options (experimental):

    --cold       Do not scan files on destination and only use local databases
    --rsync      Use rsync for copying files

  configuration options:

    --nolog      Disable writing log and file databases to:
                    <source>/.backupy/Logs/log-yymmdd-HHMM.csv
                    <source|dest>/.backupy/database.json
    -p, --posix  Force posix style paths on non-posix operating systems
    -k, --save   Save configuration to <source>/.backupy/config.json and exit
    -l, --load   Load configuration from <source>/.backupy/config.json and run

  BackuPy is a simple backup program in python with an emphasis on data
  integrity and transparent behaviour - https://github.com/elesiuta/backupy

  BackuPy comes with ABSOLUTELY NO WARRANTY. This is free software, and you are
  welcome to redistribute it under certain conditions. See the GNU General
  Public Licence for details.
  ```

  - The config file is saved to, and loaded from `<source>/.backupy/config.json`
    - it contains all the options from the command line interface along with some additional options
    - the only CLI options that can be used with `--load` and can override settings in `config.json` are `-c mode`, `--dbscan`, and `--dry-run`
      - the overrides can enable `--dbscan` or `--dry-run` but not disable
    - see `backupy/config.py` for where all the options and defaults are stored in code
    - below is a description of all the other options that are available
  - `source_unique_id` & `dest_unique_id`
    - unique id for each folder, used when `write_database_x2` is enabled, each assigned a random string by default
  - `archive_dir` = ".backupy/Archive"
    - can be any subdirectory
  - `config_dir` = ".backupy"
    - can't be changed under normal operation
  - `log_dir` = ".backupy/Logs"
    - can be any subdirectory
  - `trash_dir` = ".backupy/Trash"
    - can be any subdirectory
  - `cleanup_empty_dirs` = True
    - delete directories when they become empty
  - `root_alias_log` = True
    - abbreviate absolute paths to source and dest with `<source>` and `<dest>` in logs
  - `stdout_status_bar` = True
    - show progress status bar
  - `verbose` = True
    - print list of differences between directories to stdout
  - `write_database_x2` = False
    - write both source and destination databases to each side using their `unique_id`, useful for syncing groups of more than two folders or with the `--sync-delete` flag
  - `write_log_dest` = False
    - write a copy of the log to `<dest>/<log_dir>/log-yymmdd-HHMM-dest.csv`
  - `write_log_summary` = False
    - alternative log structure, written in addition to standard log
  - `nocolour` = False
    - disable colour when printing to stdout

  - Run tests with
  ```
  python setup.py test
  ```
  - Building a python package
  ```
  python setup.py sdist
  ```
  - Building an executable with the GUI (depends on [Gooey](https://pypi.org/project/Gooey/)) (deprecated, may rewrite with flutter)
  ```
  pyinstaller build.spec
  ```
  - You can package the executable on Windows by running setup.iss with Inno Setup


pkgId: a255b6c41c4973acdf0345c8462ad229a1e074969c8126dc3003188b7fe53f5c
name: python-BactInspectorMax
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Package to investigate mash hits against refseq
url: https://pypi.org/project/BactInspectorMax/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BactInspectorMax-0.1.3-1.src.rpm
checksum_type: sha256
description:
  A package to

  1. determine the most probable species based on sequence in fasta/fastq files using refseq and Mash (https://mash.readthedocs.io/en/latest/index.html)
  It will count the species of the top ref seq mash matches and report most frequent.
  2. determine the closest reference in refseq to a set of fasta/fastq files

  The PyPi package is called BactInspectorMax since my original BactInspector asked for the path to a sketch
  of refseq genomes. In May 2019 a new curated mash sketch of complete bacterial refseq genome was
  created and bundled into the package. This required a special request to increase the PyPi package limit,
  hence the Max.
  The command is still `bactinspector <sub command>` however.


  The data bundled into bactinspector are the complete bacterial refseq genomes from May 2019. The species assignations have been corrected by changing species where the majority does not match the species described within the refseq info found [here](ftp://ftp.ncbi.nlm.nih.gov/genomes/refseq/bacteria/assembly_summary.txt) and the excellent [Bacsort resource](https://github.com/rrwick/Bacsort) from [Ryan Wick](https://twitter.com/rrwick)


  [Mash](https://github.com/marbl/Mash/) (> v2.1)
  Installation with conda is recommended


  pip3 install bactinspectorMax


  ```
  usage: bactinspector [-h] [-v]
                       {check_species,closest_match,info,create_species_info} ...

  A module to determine the most probable species based on sequence in fasta files using refseq and Mash (https://mash.readthedocs.io/en/latest/index.html)
  It will count the species of the top ref seq mash matches and report most frequent.

  In order to use the module:
    • Specify an input directory and output directory (default is current directory)
    • Specify either a
      • fasta file pattern with -f (e.g "*.fas") or
      • mash sketch file pattern with -m (e.g "*.msh") if you have already sketched the fasta files
    • By default the top 10 matches will be used. Change this with -n
    • Speed things up by changing the number of parallel processes to match the cores on your computer using -p
    • If mash is not in your PATH specify the directory containing the mash executable with -mp

  If you want to update the genomes used, follow the instructions on https://gitlab.com/antunderwood/bactinspector/wikis/Updating-the-genomes-in-BactInspector
  and use the create_species_info command to make the required file

  positional arguments:
    {check_species,closest_match,create_species_info}
                          The following commands are available. Type
                          bactinspector <COMMAND> -h for more help on a specific
                          commands
      check_species       Check the most frequent matches to a species in refseq
      closest_match       Report the closest matches to a set of sequences
      create_species_info
                          Create species info TSV for locally created mash
                          sketches
      info                Provide information about the data in bactinspector
  optional arguments:
    -h, --help            show this help message and exit
    -v, --version         print out software version
  ```


  Assign a species using matches to refseq. Based on observed intra-species mash distances, a result maybe marked as uncertain if the distance to the best hit is greater than 1.2 x the observed maximum intra-species distance.
  ```
  usage: bactinspector check_species [-h] [-i INPUT_DIR] [-o OUTPUT_DIR]
                                     [-p PARALLEL_PROCESSES]
                                     [-n NUM_BEST_MATCHES] [-d DISTANCE_CUTOFF]
                                     [-v ALLOWED_VARIANCE]
                                     [-vl ALLOWED_VARIANCE_RARER_SPECIES] [-s]
                                     [-l LOCAL_MASH_AND_INFO_FILE_PREFIX]
                                     [-mp MASH_PATH]
                                     (-f FASTA_FILE_PATTERN | -fq FASTQ_FILE_PATTERN | -m MASH_SKETCH_FILE_PATTERN)

  optional arguments:
    -h, --help            show this help message and exit
    -i INPUT_DIR, --input_dir INPUT_DIR
                          path to input_directory
    -o OUTPUT_DIR, --output_dir OUTPUT_DIR
                          path to output_directory
    -p PARALLEL_PROCESSES, --parallel_processes PARALLEL_PROCESSES
                          number of processes to run in parallel
    -n NUM_BEST_MATCHES, --num_best_matches NUM_BEST_MATCHES
                          number of best matches to return
    -d DISTANCE_CUTOFF, --distance_cutoff DISTANCE_CUTOFF
                          mash distance cutoff (default 0.05)
    -v ALLOWED_VARIANCE, --allowed_variance ALLOWED_VARIANCE
                          proportion of max_distance allowed over which a result
                          will be marked as uncertain (default 0.1)
    -vl ALLOWED_VARIANCE_RARER_SPECIES, --allowed_variance_rarer_species ALLOWED_VARIANCE_RARER_SPECIES
                          proportion of max_distance allowed over which a result
                          will be marked as uncertain for species which have
                          fewer than 10 representatives in refseq (default 0.5)
    -s, --stdout_summary  output a summary of the result to STDOUT
    -l LOCAL_MASH_AND_INFO_FILE_PREFIX, --local_mash_and_info_file_prefix LOCAL_MASH_AND_INFO_FILE_PREFIX
                          the path prefix to the mash sketch file and
                          corresponding info file
    -mp MASH_PATH, --mash_path MASH_PATH
                          path to the mash executable. If not provided it is
                          assumed mash is in the PATH
    -f FASTA_FILE_PATTERN, --fasta_file_pattern FASTA_FILE_PATTERN
                          pattern to match fasta files e.g "*.fas"
    -fq FASTQ_FILE_PATTERN, --fastq_file_pattern FASTQ_FILE_PATTERN
                          pattern to match fastq files e.g "*.fastq.gz"
    -m MASH_SKETCH_FILE_PATTERN, --mash_sketch_file_pattern MASH_SKETCH_FILE_PATTERN
                          pattern to match mash sketch files e.g "*.msh"
  ```


  Find the closest match of a set of genomes to genomes within refseq. Useful as an objective way of choosing a reference genome when mapping

  ```
  usage: bactinspector closest_match [-h] [-i INPUT_DIR] [-o OUTPUT_DIR]
                                     [-p PARALLEL_PROCESSES] [-r]
                                     [-l LOCAL_MASH_AND_INFO_FILE_PREFIX]
                                     [-mp MASH_PATH]
                                     (-f FASTA_FILE_PATTERN | -fq FASTQ_FILE_PATTERN | -m MASH_SKETCH_FILE_PATTERN)

  optional arguments:
    -h, --help            show this help message and exit
    -i INPUT_DIR, --input_dir INPUT_DIR
                          path to input_directory
    -o OUTPUT_DIR, --output_dir OUTPUT_DIR
                          path to output_directory
    -p PARALLEL_PROCESSES, --parallel_processes PARALLEL_PROCESSES
                          number of processes to run in parallel
    -r, --ref_and_rep_only
                          only include reference and representative sequences
    -l LOCAL_MASH_AND_INFO_FILE_PREFIX, --local_mash_and_info_file_prefix LOCAL_MASH_AND_INFO_FILE_PREFIX
                          the path prefix to the mash sketch file and
                          corresponding info file
    -mp MASH_PATH, --mash_path MASH_PATH
                          path to the mash executable. If not provided it is
                          assumed mash is in the PATH
    -f FASTA_FILE_PATTERN, --fasta_file_pattern FASTA_FILE_PATTERN
                          pattern to match fasta files e.g "*.fas"
    -fq FASTQ_FILE_PATTERN, --fastq_file_pattern FASTQ_FILE_PATTERN
                          pattern to match fastq files e.g "*.fastq.gz"
    -m MASH_SKETCH_FILE_PATTERN, --mash_sketch_file_pattern MASH_SKETCH_FILE_PATTERN
                          pattern to match mash sketch files e.g "*.msh"
  ```

  Find out what sequences are present in the mash sketch using a term to search the species name. You can either specify `-s` to search the aggregated species information or `-i` to search the individual refseq records.

  ```
  usage: bactinspector info [-h] -t SEARCH_TERM (-s | -i)

  optional arguments:
    -h, --help            show this help message and exit
    -t SEARCH_TERM, --search_term SEARCH_TERM
                          search term to use when searching species within
                          bactinspector
    -s, --summary         search the aggregate data
    -i, --individual_records
                          search the individual refseq records
  ```



  An updated mash sketch file and corresponding info file can be created using the process described [here](https://gitlab.com/antunderwood/bactinspector/wikis/Updating-the-genomes-in-BactInspector)
  This process uses the create_species_info commmand

  ```
  usage: bactinspector create_species_info [-h] -m MASH_INFO_FILE -r
                                           REFSEQ_SUMMARY_FILE -b
                                           BACSORT_SPECIES_FILE -x
                                           BACSORT_EXCLUDED_ASSEMBLIES_FILE

  optional arguments:
    -h, --help            show this help message and exit
    -m MASH_INFO_FILE, --mash_info_file MASH_INFO_FILE
                          path to info file created using mash info -t
    -r REFSEQ_SUMMARY_FILE, --refseq_summary_file REFSEQ_SUMMARY_FILE
                          path to refseq assembly summary file downloaded via
                          wget ftp://ftp.ncbi.nlm.nih.gov/genomes/refseq/bacteri
                          a/assembly_summary.txt
    -b BACSORT_SPECIES_FILE, --bacsort_species_file BACSORT_SPECIES_FILE
                          path to bacsort_species_definitions.txt
    -x BACSORT_EXCLUDED_ASSEMBLIES_FILE, --bacsort_excluded_assemblies_file BACSORT_EXCLUDED_ASSEMBLIES_FILE
                          path to bacsort_excluded_assemblies.txt
  ```


pkgId: 8a2adeffb65f82de75dc201537547275db7931ce79a3cd8f85b3bcd3da936cc4
name: python-BambooChute
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Advanced data cleaning built on top of Pandas
url: https://github.com/itaymev/bamboo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BambooChute-1.0.4-1.src.rpm
checksum_type: sha256
description:
  **BambooChute** is a comprehensive data cleaning toolkit built on top of Pandas, offering a vast array of functions to streamline your data preparation process. From handling missing data to detecting outliers, managing categorical data, and ensuring data integrity, BambooChute empowers data analysts, scientists, and engineers to work more efficiently with their data.



  - [Features](#features)
  - [Installation](#installation)
  - [Getting Started](#getting-started)
  - [Functionality Overview](#functionality-overview)
    - [Loading Data](#loading-data)
    - [Handling Missing Data](#handling-missing-data)
    - [Outlier Detection and Removal](#outlier-detection-and-removal)
    - [Categorical Data Processing](#categorical-data-processing)
    - [Date Handling and Transformation](#date-handling-and-transformation)
    - [Data Type Validation](#data-type-validation)
    - [Duplicate Management](#duplicate-management)
    - [Data Formatting](#data-formatting)
    - [Data Profiling](#data-profiling)
  - [Testing](#testing)
  - [Contributing](#contributing)
  - [License](#license)



  - **Versatile Data Loading:** Seamlessly load data from multiple formats (CSV, Excel, JSON, and Pandas DataFrames).
  - **Comprehensive Missing Data Handling:** Use a variety of imputation strategies (mean, median, KNN, regression, etc.) and drop methods.
  - **Flexible Outlier Detection & Removal:** Detect outliers using various methods (Z-score, IQR, Isolation Forest, etc.) with detailed configuration options.
  - **Efficient Categorical Data Processing:** Convert, encode, map, and manage rare categories with ease.
  - **Robust Date Handling:** Convert dates, extract date parts, handle invalid dates, and calculate date differences.
  - **Data Validation Tools:** Validate data types, check for missing data, and ensure value consistency.
  - **Duplicate Management:** Identify, mark, merge, and handle near-duplicates with options for fuzzy matching.
  - **Consistent Data Formatting:** Clean string data by trimming whitespace, standardizing cases, and removing special characters.
  - **Data Profiling:** Generate summary reports on missing data, outliers, distribution, and correlations for a comprehensive overview.



  Install BambooChute via pip:

  ```bash
  pip install BambooChute
  ```

  Ensure dependencies from `requirements.txt` are installed:

  ```bash
  pip install -r requirements.txt
  ```



  Here’s an example to get you started with loading data, handling missing values, detecting outliers, and exporting the cleaned data:

  ```python
  import pandas as pd
  from BambooChute import Bamboo


  data = pd.read_csv('data.csv')


  bamboo = Bamboo(data)


  print(bamboo.preview_data())


  bamboo.impute_missing(strategy='mean')


  bamboo.detect_outliers_zscore(threshold=3)


  bamboo.export_data('cleaned_data.csv')
  ```





  BambooChute makes it easy to load data from various sources. The `Bamboo` class can accept:
  - **CSV**: Read from a CSV file path.
  - **Excel**: Read from an Excel file.
  - **JSON**: Load data from a JSON file.
  - **Pandas DataFrame**: Load data directly from an in-memory DataFrame.

  ```python

  bamboo = Bamboo('data.csv')
  bamboo = Bamboo(df)
  ```

  This flexibility allows BambooChute to be integrated with most data pipelines, irrespective of the data source.



  The package offers multiple imputation methods to fill missing values, including:
  - **Mean, Median, and Mode Imputation**: Fill missing values in numeric columns using statistical averages.
  - **K-Nearest Neighbors (KNN)**: Impute values based on the values of nearby points, ensuring continuity in numerical patterns.
  - **Custom Functions**: Define your own function for filling missing values.

  Example Usage:

  ```python

  bamboo.impute_missing(strategy='mean')


  bamboo.impute_knn(n_neighbors=5)


  bamboo.drop_missing(axis=0, how='any')
  ```

  Each function supports optional parameters to control which columns are affected, allowing for precise control over data imputation.



  Outliers can distort your data analysis, so BambooChute offers several detection methods:
  - **Z-score Detection**: Identifies outliers by measuring how many standard deviations a value is from the mean.
  - **IQR (Interquartile Range)**: Detects values outside a specific range based on the first and third quartiles.
  - **Isolation Forest and DBSCAN**: Use machine learning to detect outliers in complex datasets.

  Example Usage:

  ```python

  outliers = bamboo.detect_outliers_zscore(threshold=3)


  bamboo.remove_outliers(method='iqr', multiplier=1.5)


  bamboo.remove_outliers_isolation_forest(contamination=0.1)
  ```



  BambooChute makes it easy to manage categorical data with functions for:
  - **Conversion to Categorical**: Change columns to categorical types.
  - **Encoding**: Convert categories to one-hot or label encodings.
  - **Rare Category Detection**: Identify and replace rare categories to improve model performance.

  Example Usage:

  ```python

  bamboo.convert_to_categorical(['column'])


  bamboo.encode_categorical(method='onehot')


  rare_categories = bamboo.detect_rare_categories(column='category_column', threshold=0.05)
  bamboo.replace_rare_categories(column='category_column', replacement='Other')
  ```



  BambooChute simplifies working with dates, offering tools for:
  - **Conversion to Datetime**: Convert columns to a datetime format.
  - **Extraction of Date Parts**: Extract parts of a date (year, month, day).
  - **Date Range Creation**: Generate sequences of dates.
  - **Date Differences**: Calculate differences between dates.

  Example Usage:

  ```python

  bamboo.convert_to_datetime(['date_column'])


  bamboo.extract_date_parts('date_column', parts=['year', 'month'])


  bamboo.calculate_date_differences(start_column='start_date', end_column='end_date')
  ```



  Data integrity is critical, and BambooChute’s data type validation tools allow you to:
  - **Check Consistency**: Identify columns with mixed types.
  - **Convert Data Types**: Enforce specific types across columns.
  - **Identify Invalid Types**: Detect rows with types that don’t match the expected type for a column.

  Example Usage:

  ```python

  consistency = bamboo.check_dtype_consistency()


  bamboo.enforce_column_types({'age': 'int64', 'price': 'float64'})
  ```



  Efficiently manage duplicates with functions for:
  - **Identifying Duplicates**: Find duplicate rows.
  - **Dropping Duplicates**: Remove duplicate rows, keeping specific occurrences.
  - **Near-Duplicate Detection**: Identify nearly identical values using fuzzy matching.

  Example Usage:

  ```python

  duplicates = bamboo.identify_duplicates(subset=['name'])


  bamboo.drop_duplicates(keep='first')


  bamboo.handle_near_duplicates(column='name', threshold=0.8)
  ```



  BambooChute’s formatting tools allow you to standardize data appearance:
  - **Whitespace Management**: Trim excess whitespace from strings.
  - **Case Standardization**: Convert text to lowercase, uppercase, or title case.
  - **Special Character Removal**: Clean up text fields by removing unwanted symbols.

  Example Usage:

  ```python

  bamboo.trim_whitespace()


  bamboo.standardize_case(case='title')


  bamboo.remove_special_characters(columns=['text_column'], chars_to_remove='@#$')
  ```



  Gain insights into your data by generating summary reports, allowing for a deeper understanding of data structure and issues.

  ```python

  summary = bamboo.generate_summary_report()
  ```



  The BambooChute package uses **pytest** for testing. To execute all tests in the `tests` directory, run:

  ```bash
  pytest tests/
  ```

  For more detailed output, add the `-v` flag for verbose mode or `--maxfail=3` to stop after three failures. This ensures every function is well-tested for reliability and performance.



  To contribute:

  1. Go the homepage, fork the repository.
  2. Create a new branch.
  3. Make changes and submit a pull request with your email.
    - You will receive an email asking about your changes, please reply.
  4. Thanks for contributing!



  BambooChute is licensed under the MIT License.


pkgId: e6206ff6e222c5ecc154e3dd3fe0d7f80e88672443301f020b4837e91f381194
name: python-Banner-Ad-Toolkit
arch: src
version: 0.3.2
epoch: 0
release: 1
description: Author: Tim Santor tsantor@xstudios.agency
url: https://bitbucket.org/tsantor/banner-ad-toolkit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Banner-Ad-Toolkit-0.3.2-1.src.rpm
checksum_type: sha256
summary:
  A command line tool to aid in the development of banner ad campaigns. Auto generates PSDs at the required sizes with specified filenames to get you started, then when done designing, exports static banners at or under max file sizes specified. All managed via a very simple manifest file.


pkgId: 63f022b3ecc7771eac08a8cbebec90c7315a458a25b2e73ddba54e988ce8f54e
name: python-BaseHash
arch: src
version: 3.0.10
epoch: 0
release: 1
summary: Reversible obfuscated identifier hashes.
url: http://bnlucas.github.io/python-basehash
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BaseHash-3.0.10-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/bnlucas/python-basehash.png?branch=master)](https://travis-ci.org/bnlucas/python-basehash)


  BaseHash is now deprecated and will no longer be maintained.
  [Obfuskey](https://github.com/bnlucas/obfuskey) has been created to replace it. A
  decision made when looking to modernize this utility. Obfuskey is only tested on
  python3.6 and higher, so if you're needing lower support, you can continue to use
  BaseHash.

  BaseHash is a small library for creating reversible obfuscated identifier hashes
  to a given base and length. The project is based on the GO library, [PseudoCrypt][pc]
  by [Kevin Burns][kb]. The library is extendible to use custom alphabets and other
  bases.

  The library uses golden primes and the [Baillie-PSW][bp] primality test or the
  `gmpy2.is_prime` (if available) for hashing to `maximum` length (`base ** length - 1`).



  A massive overhaul was done with the primality algorithms. Including support for
  [gmpy2][gmp] if it available on the system for that much more of an increase.

  All methods being used to check primality in `primes.py` have been optimized and
  benchmarked to try to get the best possible preformance when `gmpy2.is_prime`
  and `gmpy2.next_prime` are not available.




  ```
  pip install basehash
  ```



  ```
  nosetests tests/
  ```

  [pc]: https://github.com/KevBurnsJr/pseudocrypt
  [kb]: https://github.com/KevBurnsJr
  [bp]: http://en.wikipedia.org/wiki/Baillie-PSW_primality_test
  [gmp]: https://gmpy2.readthedocs.org/

rpm_license:
  Copyright 2013-2019 Nathan Lucas  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: ecced2f4b71c0bf64e9dadf9e293deee6f5f425863cc5b79496d16e68a3ed829
name: python-BaseModel
arch: src
version: 20190604.1625
epoch: 0
release: 1
summary: SqlAlchemy's spuer class
url: https://github.com/billsteve
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BaseModel-20190604.1625-1.src.rpm
checksum_type: sha256
description:
  **Just For Test**

      Not safe,not stable and will boom boom boom.

      Just like these:
          -  https://music.163.com/song?id=3949444&userid=319278554
          -  https://music.163.com/song?id=474581010&userid=319278554
          -  https://open.spotify.com/album/47wyCwrChF50ZTFNOuWx99
          -  https://open.spotify.com/track/3oDFtOhcN08qeDPAK6MEQG


pkgId: d5f7d5ffbdf10a80dee79934af94a37924187f6477130bb6896ae3331fbd1186
name: python-BaseNN
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/OpenXLab-Edu/OpenMMLab-Edu
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BaseNN-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  BaseNN can easily build neural networks layer by layer and deeply explore the neural network principle.


pkgId: 32fe29f009374c9427f5901e05b965d5fa2110e12c8c60767f01faf151bc8f2b
name: python-BaselineRemoval
arch: src
version: 0.1.6
epoch: 0
release: 1
url: https://github.com/StatguyUser/BaselineRemoval
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BaselineRemoval-0.1.6-1.src.rpm
checksum_type: sha256
summary:
  Perform baseline removal, baseline correction and baseline substraction for raman spectra using Modpoly, ImodPoly and Zhang fit. Returns baseline-subtracted spectrum

description:
  Companion python library for the machine learning book [Feature Engineering & Selection for Explainable Models: A Second Course for Data Scientists](https://statguyuser.github.io/feature-engg-selection-for-explainable-models.github.io/index.html). It is used for baseline correction. It has below 3 methods for baseline removal from spectra.
    - **Modpoly** Modified multi-polynomial fit [1]. It has below 3 parameters.
    1) `degree`, it refers to polynomial degree, and default value is 2.
    2) `repitition`, it refers to how many iterations to run, and default value is 100.
    3) `gradient`, it refers to gradient for polynomial loss, default is 0.001. It measures incremental gain over each iteration. If gain in any iteration is less than this, further improvement will stop.
    - **IModPoly** Improved ModPoly[2], which addresses noise issue in ModPoly. It has below 3 parameters.
    1) `degree`, it refers to polynomial degree, and default value is 2.
    2) `repitition`, it refers to how many iterations to run, and default value is 100.
    3) `gradient`, it refers to gradient for polynomial loss, and default is 0.001. It measures incremental gain over each iteration. If gain in any iteration is less than this, further improvement will stop.
    - **ZhangFit** Zhang fit[3], which doesn’t require any user intervention and prior information, such as detected peaks. It has below 3 parameters.
    1) `lambda_`, it can be adjusted by user. The larger lambda is,  the smoother the resulting background. Default value is 100.
    2) `porder` refers to adaptive iteratively reweighted penalized least squares for baseline fitting. Default value is 1.
    3) `repitition` is how many iterations to run, and default value is 15.
  We can use the python library to process spectral data through either of the techniques ModPoly, IModPoly or Zhang fit algorithm for baseline subtraction. The functions will return baseline-subtracted spectrum.


pkgId: e38794ea4d9578539d80835587cfc333d76d983746d17be65474e52c724d1bd1
name: python-BashMetaHandler
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: bmh
url: https://github.com/000AG000/BashMetaHandler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BashMetaHandler-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/BashMetaHandler.svg)][pypi_]
  [![Status](https://img.shields.io/pypi/status/BashMetaHandler.svg)][status]
  [![Python Version](https://img.shields.io/pypi/pyversions/BashMetaHandler)][python version]
  [![License](https://img.shields.io/pypi/l/BashMetaHandler)][license]

  [![Read the documentation at https://BashMetaHandler.readthedocs.io/](https://img.shields.io/readthedocs/BashMetaHandler/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/000AG000/BashMetaHandler/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/000AG000/BashMetaHandler/branch/main/graph/badge.svg)][codecov]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]

  [pypi_]: https://pypi.org/project/BashMetaHandler/
  [status]: https://pypi.org/project/BashMetaHandler/
  [python version]: https://pypi.org/project/BashMetaHandler
  [read the docs]: https://BashMetaHandler.readthedocs.io/
  [tests]: https://github.com/000AG000/BashMetaHandler/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/000AG000/BashMetaHandler
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  It provites an interpreter for a own bash meta languange. Currently only tested for linux systems.



  click>=8.1.7 ; python_version >= "3.7" and python_version < "4.0"
  colorama>=0.4.6 ; python_version >= "3.7" and python_version < "4.0" and platform_system == "Windows"
  datetime>=5.5 ; python_version >= "3.7" and python_version < "4.0"
  importlib-metadata>=4.2.0 ; python_version >= "3.7" and python_version < "3.8"
  pexpect>=4.9.0 ; python_version >= "3.7" and python_version < "4.0"
  ptyprocess>=0.7.0 ; python_version >= "3.7" and python_version < "4.0"
  pytz>=2024.1 ; python_version >= "3.7" and python_version < "4.0"
  setuptools>=68.0.0 ; python_version >= "3.7" and python_version < "4.0"
  typing-extensions>=4.7.1 ; python_version >= "3.7" and python_version < "3.8"
  zipp>=3.15.0 ; python_version >= "3.7" and python_version < "3.8"
  zope-interface>=6.4.post2 ; python_version >= "3.7" and python_version < "4.0"



  You can install _bmh_ via [pip] from [PyPI]:

  ```console
  $ pip install BashMetaHandler
  ```



  The main purpose of this library is to provide an interpreter for the self-created metabashlanguage. The MetaBashHandler-class handles this interpretation. When on object of this class is created it initiates a bash terminal where the interpreted language is executed.

  Firstly, it a provided file is read and lines for the goto-command are searched and indexed. They must be a word followed by an ":".Secondly, the execute_file function will run the interpreter.

  The metabashlanguange has normally the ending ".msh". When not a special case the input goes directly to the bash terminal. It has the advantage to not care whether you are directly in the bash terminal are input of a program run by the terminal. Keywords implemented are: while, if, elif, else. When used you have to use a tab to indicate how long these keywords effect should be (similar to python).

  Additionally you are provided with functions to be used. They are used as follows functionname(arg1,arg2,...). There are a few prebuild functions to use given as default parameters to the MetaBashHandler. These are: check, do_not, equal, expect, expect_check, get_input, println and wait. The actual functionname are sometimes different to the actual python functionnames. You can also create your own function, the first argument should always be the MetaBashHandler object.

  Finally there you can use variables indicated by $(variable name). They will be replaced with the content of the variable given to the MetaBashHandler object.

  Please see the [Command-line Reference] for details.



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _bmh_ is free and open source software.



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project was generated from [@cjolowicz]'s [Hypermodern Python Cookiecutter] template.

  [@cjolowicz]: https://github.com/cjolowicz
  [pypi]: https://pypi.org/
  [hypermodern python cookiecutter]: https://github.com/cjolowicz/cookiecutter-hypermodern-python
  [file an issue]: https://github.com/000AG000/BashMetaHandler/issues
  [pip]: https://pip.pypa.io/

  <!-- github-only -->

  [license]: https://github.com/000AG000/BashMetaHandler/blob/main/LICENSE
  [contributor guide]: https://github.com/000AG000/BashMetaHandler/blob/main/CONTRIBUTING.md
  [command-line reference]: https://BashMetaHandler.readthedocs.io/en/latest/usage.html


pkgId: 71cc6dbb53519f78b136cc323bb583a6f2037cf0f861be94125885860238515d
name: python-BasisTheoryClient
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/BasisTheoryClient/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BasisTheoryClient-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2FBasis-Theory%2Fpython-sdk)
  [![pypi](https://img.shields.io/pypi/v/BasisTheoryClient)](https://pypi.python.org/pypi/BasisTheoryClient)

  The BasisTheory Python library provides convenient access to the BasisTheory API from Python.



  API reference documentation is available [here](https://api.basistheory.com).



  ```sh
  pip install BasisTheoryClient
  ```



  Instantiate and use the client with the following:

  ```python
  from basis_theory import BasisTheory

  client = BasisTheory(
      api_key="YOUR_API_KEY",
  )
  client.tenants.self_.get()
  ```



  The SDK also exports an `async` client so that you can make non-blocking calls to our API.

  ```python
  import asyncio

  from basis_theory import AsyncBasisTheory

  client = AsyncBasisTheory(
      api_key="YOUR_API_KEY",
  )


  async def main() -> None:
      await client.tenants.self_.get()


  asyncio.run(main())
  ```



  When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
  will be thrown.

  ```python
  from basis_theory.core.api_error import ApiError

  try:
      client.tenants.self_.get(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```



  Paginated requests will return a `SyncPager` or `AsyncPager`, which can be used as generators for the underlying object.

  ```python
  from basis_theory import BasisTheory

  client = BasisTheory(
      api_key="YOUR_API_KEY",
  )
  response = client.applications.list()
  for item in response:
      yield item

  for page in response.iter_pages():
      yield page
  ```





  The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
  as the request is deemed retriable and the number of retry attempts has not grown larger than the configured
  retry limit (default: 2).

  A request is deemed retriable when any of the following HTTP status codes is returned:

  - [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
  - [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
  - [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)

  Use the `max_retries` request option to configure this behavior.

  ```python
  client.tenants.self_.get(..., {
      "max_retries": 1
  })
  ```



  The SDK defaults to a 60 second timeout. You can configure this with a timeout option at the client or request level.

  ```python

  from basis_theory import BasisTheory

  client = BasisTheory(
      ...,
      timeout=20.0,
  )



  client.tenants.self_.get(..., {
      "timeout_in_seconds": 1
  })
  ```



  You can override the `httpx` client to customize it for your use-case. Some common use-cases include support for proxies
  and transports.
  ```python
  import httpx
  from basis_theory import BasisTheory

  client = BasisTheory(
      ...,
      httpx_client=httpx.Client(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Additions made directly to this library would have to be moved over to our generation code,
  otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
  a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
  an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 3fbfe0dfa1932f15aedf0e650c899b4ff9b2b2bda28ba457d9173d7a681b51d9
name: python-Bast
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Simple yet Elegant Web Framework with MVC Patterns
url: https://github.com/moluwole/Bast
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bast-1.0.1-1.src.rpm
checksum_type: sha256
description:
  |travis| |circleci| |python| |license| |coverall| |status| |issues| |contributors| |downloads|
  About Bast
  ~~~~~~~~~~~~~
  Bast is a Simple and Elegant Framework. The main aim of Bast is to create an enjoyable and creative Experience for Developers. Bast attempts to take the pain out of development by making common tasks used in the majority of web projects easy. Bast is aimed to be platform Independent and it's core Language is Python. Uses Python 3.*
  Python Version
  ~~~~~~~~~~~~~~~~~
  Bast makes use of Python 3.0 and above in order to run
  Usage
  ~~~~~~~~~
  To install Bast, you can download it easily from Pypi using
      $ pip install Bast
  Bast comes bundled with a very powerful CLI tool called ``panther``. To show the available commands, use
      $ panther --help
  To create a setup a new project, use
      $ panther new project_name
      $ cd project
      $ panther install
      $ panther run
  To visit the website and see if it's setup successfully, visit ``127.0.0.1:2000`` in your browser
  Update
  ~~~~~~~~~
  Bast Routing is now relatively simple and much more easy to use. It embodies the way and manner Laravel defines it's URL's but instead of the ``@`` symbol, Bast makes use of the ``.``
  You do not need to import your controller again
      from bast import Route
      route = Route()
      route.get('/', 'ExampleController.index')
  Bast Controllers are Python Classes which inherit from the Bast Controller Class. Using ``panther create:controller ControllerName`` creates a controller file in the controller package. To render template in controller, use ``self.view('template.html', args=None)`` where the args is a Dictionary object and optional
      from bast import Controller
      class TestController(Controller):
          def index(self):
              self.view('index.html')
  To run your app use
      $ panther run
  Maintainer
  ~~~~~~~~~~~~~~~~
      $  Majiyagbe Oluwole
  Contributors
  ~~~~~~~~~~~~~~~~~~
      $ Majiyagbe Oluwole
      $ Azeez Abiodun Solomon
  License
  ~~~~~~~~~
  This Framework is Licensed under MIT License
  Credits
  ~~~~~~~~~
  Bast runs on the `Tornado HTTP Server`_.
  For templating, Bast makes use of the `Jinja Templating`_ Engine.
  Eloquent Object Relation Mapping is achieved using `Orator ORM`_


pkgId: 1b916075c0ef57f05cd1483d0837a449910e6010429e3d595c1df58dc2a5b083
name: python-BatAnalysis
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Routines for analyzing data from BAT on the Neil Gehrels Swift Observatory
url: https://github.com/parsotat/BatAnalysis
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BatAnalysis-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  *** Thanks for checking out the Best-README-Template. If you have a suggestion
  *** that would make this better, please fork the repo and create a pull request
  *** or simply open an issue with the tag "enhancement".
  *** Thanks again! Now go create something AMAZING! :D
  ***
  ***
  ***
  *** To avoid retyping too much info. Do a search and replace for the following:
  *** lazzati-astro, MCRaT, twitter_handle, email, project_title, project_description


  steps to upload a distribution to PyPi is at: https://stackoverflow.com/questions/1471994/what-is-setup-py
  -->



  <!-- PROJECT SHIELDS -->
  <!--
  *** I'm using markdown "reference style" links for readability.
  *** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
  *** See the bottom of this document for the declaration of the reference variables
  *** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
  *** https://www.markdownguide.org/basic-syntax/#reference-style-links
  -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![Google Scholar Badge](https://img.shields.io/badge/Google-Scholar-lightgrey)](https://scholar.google.com/citations?user=cIxaj3MAAAAJ&hl=en)
  [![ResearchGate Badge](https://img.shields.io/badge/Research-Gate-9cf)](https://www.researchgate.net/profile/Tyler-Parsotan)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7916509.svg)](https://doi.org/10.5281/zenodo.7916509)
  <a href="https://ascl.net/2304.003"><img src="https://img.shields.io/badge/ascl-2304.003-blue.svg?colorB=262255" alt="ascl:2304.003" /></a>

  <!-- PROJECT LOGO -->
  <br />
  <p align="center">
    <a href="https://github.com/parsotat/BatAnalysis">
      <img src="./batanalysis/data/batanalysis_logo.jpg" alt="Logo">
    </a>

    <h3 align="center">The BatAnalysis Pipeline </h3>

    <p align="center">
      The BatAnalysis python pipeline is brings the analysis of BAT data to the convenience offered by Python.
      <br />
      <a href="https://github.com/parsotat/BatAnalysis/tree/master/Doc"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <!-- <a href="https://github.com/parsotat/BatAnalysis">View Demo</a>
      · -->
      <a href="https://github.com/parsotat/BatAnalysis/issues">Report Bug</a>
      ·
      <a href="https://github.com/parsotat/BatAnalysis/issues">Request Feature</a>
    </p>
  </p>



  <!-- TABLE OF CONTENTS -->
  <details open="open">
    <summary><h2 style="display: inline-block">Table of Contents</h2></summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
        <ul>
          <li><a href="#built-with">Built With</a></li>
        </ul>
      </li>
      <li>
        <a href="#getting-started">Getting Started</a>
        <ul>
          <li><a href="#prerequisites">Prerequisites</a></li>
          <li><a href="#installation">Installation</a></li>
        </ul>
      </li>
      <li><a href="#usage">Usage</a></li>
      <li><a href="#roadmap">Roadmap</a></li>
      <li><a href="#contributing">Contributing</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#contact">Contact</a></li>
      <li><a href="#acknowledgements">Acknowledgements</a></li>
    </ol>
  </details>



  <!-- ABOUT THE PROJECT -->


  <!-- [![Product Name Screen Shot][product-screenshot]](https://example.com) -->

  BatAnalysis is a python package that allows for the convenient analysis of BAT Survey data.
  This code allows users to:
  * easily download BAT survey data,
  * batch process the survey observations,
  * extract light curves and spectra for each survey observation for a given source,
  * create mosaiced images at different time bins, and
  * extract light curves and spectra from the mosaiced images for a given source.

  This project was developed in collaboration with the members of the BAT Team including:
  Sibasish Laha, David Palmer, Amy Lien and Craig Markwardt.



  * [Python 3](https://www.anaconda.com/products/distribution)
  * [HEASoftPy](https://heasarc.gsfc.nasa.gov/lheasoft/heasoftpy/)
  * [PyXspec](https://heasarc.gsfc.nasa.gov/xanadu/xspec/python/html/index.html)
  * [swiftbat_python](https://github.com/lanl/swiftbat_python)
  * [Swifttools](https://gitlab.com/DrPhilEvans/swifttools)
  * typical python modules ([astropy](https://www.astropy.org), [numpy](https://numpy.org), [scipy](https://scipy.org), etc.)

  <!-- GETTING STARTED -->


  To get a local copy up and running follow these simple steps.



  The following software are necessary for the BatAnalysis python module.

  1. Python 3.8 or larger
      - We recommend installing via Anaconda
  2. swiftbat_python
     - This can be easily installed via pip
  3. Swifttools
     - This can also be easily installed via pip
  4. HEASoftPy >= v1.2.1 (HEASoft >= v6.31.1)
     - The installation is included with HEASoft and the steps can be found here: [https://heasarc.gsfc.nasa.gov/lheasoft/install.html](https://heasarc.gsfc.nasa.gov/lheasoft/install.html)
  5. PyXspec
     - The installation is included with HEASoft but there may be additional steps to take if you have changed your anaconda
  version after building HEASoft. More information can be found here: [https://heasarc.gsfc.nasa.gov/xanadu/xspec/python/html/buildinstall.html](https://heasarc.gsfc.nasa.gov/xanadu/xspec/python/html/buildinstall.html)
  6. Swift BAT Pattern Noise Maps
     - The pattern maps used by the BAT team are available at: [https://zenodo.org/record/7595904#.Y9q7pS-B3T8](https://zenodo.org/record/7595904#.Y9q7pS-B3T8) for download. These maps shoud be downloaded and placed into a place where the BatAnalysis code will be able to access them.



  1a. Install the BatAnalysis package with Pip
     ```sh
     pip install BatAnalysis
     ```

  1b. Clone the repo and install
     ```sh
     git clone https://github.com/parsotat/BatAnalysis.git
     cd BatAnalysis/
     pip install -e .
     ```


  <!-- USAGE EXAMPLES -->


  The typical BatAnalysis workflow is as follows:

  1. Use astroquery to queue HEASARC for obervations within a given date range for an RA/DEC coordinate corresponding to a source of interest
  2. Download the data
  3. Run batsurvey on each observation ID
  4. Calculate the detector response matrix for each survey pointing
  5. Calculate the spectrum in each pointing
  6. Fit the spectra to obtain spectral information
  6. Calculate the light curve for the time period of interest
  7. Plot the light curve/spectral information
  8. Create mosaiced images for the time binning of interest (days, weeks, months, years)
  9. Create the total "time-integrated" mosaiced image
  10. Extract the spectra of the mosaiced images and fit them
  11. Calculate the light curve of the source from the mosaiced images
  12. Plot the light curve/spectral information for the mosaiced images

  Following these steps for the first 5 survey observation IDs for the Crab (although see the notebooks directory for recommended analysis steps):
  ```sh
  import batanalysis as ba
  import swiftbat
  import numpy as np
  import matplotlib.pyplot as plt
  from pathlib import Path
  plt.ion()

  object_name='Crab'
  catalog_name="Crab_Nebula_Pulsar"
  table = ba.from_heasarc(object_name)
  result = ba.download_swiftdata(table[:5])

  batsurvey_obs=ba.parallel.batsurvey_analysis(table["OBSID"][:5], nprocs=2)


  noise_map_dir=Path("/path/to/downloaded/PATTERN_MAPS/")
  batsurvey_obs=ba.parallel.batspectrum_analysis(batsurvey_obs, catalog_name, patt_noise_dir=noise_map_dir, nprocs=2)

  ba.plot_survey_lc(batsurvey_obs, id_list=catalog_name, calc_lc=True)

  outventory_file=ba.merge_outventory(batsurvey_obs)


  time_bins=ba.group_outventory(outventory_file, np.timedelta64(1,'M'))


  mosaic_list, total_mosaic=ba.parallel.batmosaic_analysis(batsurvey_obs, outventory_file, time_bins, nprocs=3)

  mosaic_list=ba.parallel.batspectrum_analysis(mosaic_list, catalog_name, nprocs=2)

  ba.plot_survey_lc(mosaic_list, id_list=catalog_name, calc_lc=True)

  ```

  _For more details and additional examples please refer to the [Notebooks](https://github.com/parsotat/BatAnalysis/tree/main/notebooks) directory_


  <!-- ROADMAP -->


  This package will soon be modified to include analysis of BAT event data.

  See the [open issues](https://github.com/parsotat/BatAnalysis/issues) for a list of proposed features (and known issues).



  <!-- 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**.

  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



  <!-- LICENSE -->


  Distributed under the MIT License. See `LICENSE` for more information.



  <!-- CONTACT -->


  Tyler Parsotan - [Personal Website](https://asd.gsfc.nasa.gov/Tyler.Parsotan/) - parsotat@umbc.edu

  Project Link: [https://github.com/parsotat/BatAnalysis.git](https://github.com/parsotat/BatAnalysis.git)



  <!-- ACKNOWLEDGEMENTS -->


  * In using the BatAnalysis code, we ask that you cite the following paper:
      * [Parsotan et. al. 2023 (submitted to ApJ)](https://arxiv.org/abs/2303.06255)
  * [README Template from: othneildrew/Best-README-Template](https://github.com/othneildrew/Best-README-Template)


  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/parsotat/BatAnalysis.svg?style=for-the-badge
  [contributors-url]: https://github.com/parsotat/BatAnalysis/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/parsotat/BatAnalysis.svg?style=for-the-badge
  [forks-url]: https://github.com/parsotat/BatAnalysis/network/members
  [stars-shield]: https://img.shields.io/github/stars/parsotat/BatAnalysis.svg?style=for-the-badge
  [stars-url]: https://github.com/parsotat/BatAnalysis/stargazers
  [issues-shield]: https://img.shields.io/github/issues/parsotat/BatAnalysis.svg?style=for-the-badge
  [issues-url]: https://github.com/parsotat/BatAnalysis/issues
  [license-shield]: https://img.shields.io/github/license/parsotat/BatAnalysis.svg?style=for-the-badge
   [license-url]: https://github.com/parsotat/BatAnalysis/blob/master/LICENSE
  <!-- [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://linkedin.com/in/lazzati-astro -->


pkgId: fcb7663796450a4a1aaffca6dbdc3c1aeadb492b92d332f94e1134dcad16570b
name: python-BayNet
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: (another) Python Bayesian Network library
url: https://github.com/Stoffle/BayNet
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BayNet-0.3.0-1.src.rpm
checksum_type: sha256
description:
  BayNet is a Python library for generating, sampling data from, comparing, and visualising Bayesian Networks.


  ```bash
  pip install BayNet
  ```



  ```python
  from baynet import DAG
  dag = DAG.generate("forest fire", 10, seed=1) # Creates a DAG
  dag.generate_discrete_parameters(alpha=5.0, min_levels=3, max_levels=5, seed=1) # Generates parameters
  data = dag.sample(1_000) # Samples data, returning a pandas DataFrame
  ```

  ```python
  from baynet import DAG
  DAG.generate("barabasi albert", 5, seed=1).plot() # Saves 'DAG.png' in working directory
  ```
  ![Example DAG.png](https://raw.githubusercontent.com/Stoffle/BayNet/master/example_DAG.png)



  ```python
  from baynet import DAG, metrics
  dag_1 = DAG.generate("erdos_renyi", 5,seed=1)
  dag_2 = DAG.generate("erdos_renyi", 5)
  print(metrics.shd(dag_1, dag_2)) # prints DAG SHD, in this case 3
  print(metrics.shd(dag_1, dag_2, skeleton=True)) # prints skeleton SHD, in this case 3
  dag_1.compare(dag_2).plot() # saves 'comparison.png' in working directory
  ```
  ![Example comparison.png](https://raw.githubusercontent.com/Stoffle/BayNet/master/example_comparison.png)

  Taking dag_1 to be the ground truth and dag_2 to be a structure learning result:
  - Dashed red arcs represent false negatives
  - Blue arcs are represent positives
  - Green arcs represent incorrectly directed arcs


pkgId: 7f6cd0dcad20667ec3e7bd7f242bbb23989316ae341f2e4f6fb4678e0691422e
name: python-BayesABTest
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: A package for running AB tests in a Bayesian framework.
url: https://github.com/bakermoran/BayesABTest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BayesABTest-1.0.9-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/bakermoran/BayesABTest/workflows/Build%20Status/badge.svg?branch=main)
  [![PyPI version](https://badge.fury.io/py/BayesABTest.svg)](https://badge.fury.io/py/BayesABTest)

  > **Baker Moran**

  This allows AB testers to create a standard report for test results with python. Handles multiple variant tests, with a variety of prior function types. This is meant to be an abstraction from the nitty gritty of the details of Bayesian statistics. That said, some knowledge about which prior function to use etc. will be helpful for the user.



  ![alt text](docs/package_documentation/img/one_var_continuous.png "Conversion Rate Example")



  - Install via pip (or specify pip3)

    ```bash
    pip install BayesABTest
    ```

    OR

  - Download files from [PyPi](https://pypi.org/project/BayesABTest/#files) and install





  Class implementing out of the box AB testing functionality. Simple, easy to use AB testing with many different prior function types, all in one clean interface.



  Functions allowing a user to explore different distributions with simple to user interface. Allows a user to visually learn about bayesian statistics, and inform proper prior function choice when doing Bayesian AB testing.





  For a documentation explaining and motivating the use of Bayesian statistics to evaluate A/B tests, see [documentation](docs/besyian_ab_testing/Bayesian_AB_Testing_explainer.md)



  There is a lot of documentation out there about a Bayesian framework of A/B testing. Some of the specific articles are listed below. Most of the work I came across was written in R, and I set out to create a Python implementation. The visuals were inspired by a standard template we use at Root, first written by <https://github.com/zachurchill-root>.

  Articles Reference:

  - <https://www.countbayesie.com/blog/2015/4/25/bayesian-ab-testing>
  - <https://medium.com/convoy-tech/the-power-of-bayesian-a-b-testing-f859d2219d5>
  - <https://cdn2.hubspot.net/hubfs/310840/VWO_SmartStats_technical_whitepaper.pdf>



  - `0.1.0-prealpha` - _12/02/2019_
  - `1.0.0-alpha` - _12/27/2019_
  - `1.0.1-alpha` - _01/02/2020_
  - `1.0.2-alpha` - _06/17/2020_
  - `1.0.3-alpha` - _06/17/2020_
  - `1.0.4-alpha` - _06/22/2020_
  - `1.0.5-alpha` - _06/22/2020_
  - `1.0.6-alpha` - _06/22/2020_
  - `1.0.7-alpha` - _07/09/2021_
  - `1.0.8-alpha` - _03/29/2022_
  - `1.0.9-alpha` - _03/29/2022_


pkgId: 43b6255f03826a9a997fb71919b6b4fae48f777a77e5a420202090804489f1d2
name: python-BayesNetCreacion
arch: src
version: 1.2.0
epoch: 0
release: 1
url: https://pypi.org/project/BayesNetCreacion/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BayesNetCreacion-1.2.0-1.src.rpm
checksum_type: sha256
summary:
  Library capable of creating Bayesian Networks and making probabilistic inference over them, as well additional functions

description:
  This library has the objective of building Bayesian networks and making probabilistic inference over them. Also, adding some other additional features that could serve the developers that make use of this library.

  This library has zero dependencies to assure it is futureproof, easier to debug, to contribute to and use.

  For the most part this library works over classes like BayesNetCreacion and Node, this was chosen so that in a way it could facilitate the usage of the OOP paradigm.





  For further inquiries you about the usage of the library you can consult [Usage](#usage) section of this repo or the [testing](/BayesNetCreacion/testing.py) python file to see the Burglar Alarm System example being used.







  - Created without using any dependencies/libraries.

  - Can create Bayesian Networks, represented as a dictionary.

  - Calculation of probabilistic inference given the created Bayesian Network.

  - Can check if network is fully defined or not.

  - Has the capability of returning a compact representation of the network as a string.

  - Can return the network's factors as a dictionary.

  - Is able to return the numeration of the network given evidence and a query.





  - Python 3.10.^





  ```bash

  pip install BayesNetCreacion

  ```





  ```python

  from BayesNetCreacion import BayesNetCreacion, Node #Import the library



  examplenode = Node('E') #Create a Node object

  example2node = Node('E2') #Create another Node object

  example2node.set_parents([str(examplenode)]) #Set node as parent



  bnc = BayesNetCreacion() #Instantiate the Bayes Network class





  bnc.add_node(examplenode)

  bnc.add_node(example2node)





  bnc.add_prob({

      ('E', True): 0.001,

      ('E', False): 0.999,

      ('E2', True, 'E', True): 0.25,

      ('E2', True, 'E', False): 0.9,

      ('E2', False, 'E', True): 0.75,

      ('E2', False, 'E', False): 0.1

  })









  bn = bnc.get_network()





  evidence = {'E': True}

  query = 'E2'



  result = bnc.probabilistic_inference(query, evidence) #Calculate the inference

  print(result) #Profit?





  WIP





  print(bnc.get_factors())





  WIP





  evidence = {'E': False}

  query = 'E2'

  result = bnc.pre_enum(query, evidence) #Calculate numeration

  print(result)



  ```





  👤 Andrés de la Roca

   - <a href = "https://www.linkedin.com/in/andr%C3%A8s-de-la-roca-pineda-10a40319b/">Linkedin</a>

   - <a href="https://github.com/andresdlRoca">Github</a>


pkgId: 7d98aff0e71366aad05828be302265210bd6ee911f15f4b2f0e3dd1032bd4ffa
name: python-BayesOpt4dftu
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/maituoy/BayesianOpt4dftu
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BayesOpt4dftu-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This code determines the Hubbard U parameters in DFT+U via Bayesian Optimization approach.



  1. Python 3.6+
  2. NumPy
  3. Pandas
  4. ASE (https://wiki.fysik.dtu.dk/ase/)
  5. pymatgen (https://pymatgen.org/)
  6. bayesian-optimization https://github.com/fmfn/BayesianOptimization
  7. Vienna Ab initio Simulation Package (VASP) https://www.vasp.at/



  The input file contains these parts:
  - structure_info : Includes geometry information (such as lattice parameter, lattice vectors, atomic position, etc) of the
  target materials.
    
      1. Lattice_param and cell: define the 2nd to 5th rows in your POSCAR.

        "lattice_param": 6.0584,
          "cell": [
              [
                  0.0,
                  0.5,
                  0.5
              ],
              [
                  0.5,
                  0.0,
                  0.5
              ],
              [
                  0.5,
                  0.5,
                  0.0
              ]
          ]
      2. Atoms: Define the atomic positions of each atom in your system and the initial magnetic moment if there is any.

        With SOC:
        "atoms": [
              [
                  "In",
                  [
                      0,
                      0,
                      0
                  ],
                  [
                      0,
                      0,
                      1e-06
                  ]
              ],
              [
                  "As",
                  [
                      0.75,
                      0.75,
                      0.75
                  ],
                  [
                      0,
                      0,
                      1e-06
                  ]
              ]
          ]

        Without SOC:
          "atoms": [
              [
                  "In",
                  [
                      0,
                      0,
                      0
                  ],
                   1e-06
              ],
              [
                  "As",
                  [
                      0.75,
                      0.75,
                      0.75
                  ],
                   1e-06
              ]
          ]
       So in this case, there are two atoms in the primitive cell which are located at the position `(0,0,0)` and `(0.75, 0.75, 0.75)`. The second term under each atom defines the initial magnetic moment. If the spin-orbit coupling is not included in your calculation, it is just an integer while otherwise it is a (3,) array of each element defines the initial moment of corresponding direction. If the initial moment is 0, it has to be set to a small number to avoid confliction in the ASE.
  - general_flags: Includes general flags required in the VASP calculation.
  - scf: Flags required particularly in SCF calculation.
  - band: Flags required particularly in band structure calculation.
  - pbe: Flags required when using PBE as exchange-correlation functional.
  - hse: Flags required when using HSE06 as exchange-correlation functional.
  The flags can be added or removed. More flag keys can be found in the ASE VASP calculator.



  * `pip install BayesOpt4dftu`


  To run the examples in the `example` folder, you need to modify the environment settings in the `example.py` of the selected calculation based on the specs of your system and VASP binary.

  I will use `/example/2d` as an example:



    Set the running command for VASP executable

        VASP_RUN_COMMAND = 'srun -n 54 vasp_ncl'

    Define the VASP output file name.

        OUTFILENAME = 'vasp.out'

    Define the path direct to the VASP pesudoopotential. (P.S. It should be the directory containing the `potpaw_PBE` folder)

        VASP_PP_PATH = '/PATH/TO/THE/PESUDOPOTENTIAL/'



    `--which_u` defines which element you would like to optimize the U for. For a unary substance, it has to be `(1,)`. For compounds with over 2 elements, you can set each element to 0 or 1 to switch on/off the optimization for that element. For InAs, when optimizing for both In and As, it will be `(1,1)`.

    `--br` defines band range you would like to include in your Δband. It is a tuple of two integers, which define the number of valence bands and conduction bands from the Fermi level.

    `--kappa` controls the exploration and exploitation when acquisition function sample the next points. Exploitation 0 <-- kappa --> 10 Exploration

    `--alpha1` and `alpha2` are the weight coefficients of Δgap and Δband.

    `--threshold` defines at what accuracy would you stop the BO process.

    `--urange` defines the U parameter range for optimization, currently it's not supported to define different U ranges for different elements.

    `--import_kpath` provides an external listing of high symmetry k-points in case some special k coordinates are not present in the ase library.

    `--elements` defines the elements in your system. It is set for plotting the BO results. If it's a unary substance, it has to be (ele,).

    `--iteration` defines the maximum steps that BO will be performed with.



    After setting up all these stuff, you can simply run the calculation by

    `cd example/1d`

    `python example.py --arg1 XX --arg2 XX ...`



    Once the threshold or the maximum iterations is reached, you will get two output files

    `u_xx.txt` file consists of the U parameters, band gap, and the Δband at each step.

    `1D_xxx.png` or `2D_xxx.png` plots showing you the Gaussian process predicted mean and the acquisition function.

    Example of BO plots

    <img src="https://github.com/maituoy/BayesianOpt4dftu/blob/master/example/1d/1D_kappa_5_a1_0.5_a2_0.5.png" width="600" height="400">

    <img src="https://github.com/maituoy/BayesianOpt4dftu/blob/master/example/2d/2D_kappa_5_a1_0.25_a2_0.75.png" width="800" height="270">

    Optimal U values will be output at the end of entire process based on the interpolation from the predicted mean space. You can also pick up the Us that give you largest objective value from the u.txt file.


  Please cite the following work if you use this code.

  [1] M. Yu, S. Yang, C. Wu, N. Marom, Machine learning the Hubbard U parameter in DFT+ U using Bayesian optimization, npj Computational Materials, 6(1):1–6, 2020.


pkgId: d22111a63fbd460514178e79148b998a31c93dab8e263508583ca3af57a520c8
name: python-BayesPowerlaw
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Fitting power law distributions using Bayesian Inference
url: https://github.com/AtwalLab/BayesPowerlaw
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BayesPowerlaw-1.1.3-1.src.rpm
checksum_type: sha256
description:
  BayesPowerlaw fits single or mixtures of power law distributions and estimate their exponent using Bayesian Inference,
  specifically Markov-Chain Monte Carlo Metropolis Hastings algorithm. See the Documentation page for details.

  **Installation** :
  pip install BayesPowerlaw

  Requirements

  - Python >= 3.6.2
  - numpy >= 1.10.1
  - scipy >= 1.0.0
  - matplotlib >= 2.0.0

  - Documentation: "http://BayesPowerlaw.readthedocs.org"
  - Github: "https://github.com/atwallab/BayesPowerlaw"
  - PyPI: "https://pypi.python.org/pypi/BayesPowerlaw"


pkgId: b131bc62f3465d165feb4a6e2e0bc066e0b4764afe760e60a0b8a654362f085d
name: python-Bayesian2D
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Package used to find the maximum or minimum of any 2D function using Bayesian optimization
url: https://github.com/JRaidal/Bayesian2D
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bayesian2D-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This package implements Bayesian optimization in Python for any 2D function. It uses Gaussian regression to create a surrogate function and the Maximum Probability of Improvement aquisition function to pick points to evaluate, thus finding the specified extremum of the function in only a few hundred evaluations.



  The package can simply be installed with 'pip install Bayesian2D'.



  The package contains two directories- tools and tests. The tools folder contains all the separate python functions used by the algorithm, with the Bayesian2D function being the main function of the package.

  To optimize your function just import 'from Bayesian2D.tools import Bayesian2D'. The function takes as an input the function you wish to optimize and the bounds in which you wish to search for the extremum (there are a few built in named functions such as 'Beale' or 'Ackley' with the Rosenbrock function being the default but custom functions can also be inserted). The function also requires you to specify the number of initial points evaluated, the number of optimization cycles run, the number of random points evaluated by the surrogate function each cycle, the exploration constant and whether you want to find the maximum or minimum.



  Unit tests for all the functions used can be found in the aforementioned tests directory.


pkgId: f5be73efc7278f8ecd63435a712c5c55236970de8f5be360217eda8adf5f3b78
name: python-BayesicFitting
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: A Python Toolbox for Bayesian fitting.
url: https://www.bayesicfitting.nl
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BayesicFitting-3.2.1-1.src.rpm
checksum_type: sha256
description:
  A package for model fitting and Bayesian evidence calculation.

  We have a paper out in "Astronomy and Computing" about BayesicFitting.
  [Kester and Mueller (2021)](./docs/references.md/#kester8).

  In case you are wondering what that is about take a quick look at
  [this example.](https://github.com/dokester/BayesicFitting/blob/master/BayesicFitting/examples/sealevel.ipynb)

  Citation index for the BayesicFitting package:
  DOI: 10.5281/zenodo.2597200




   + 27 March 2024 version 3.2.1<br>
     A lot of fairly small stuff.
     * __status__ changed to Alpha for some newer additions
     * Priors:
        - Adapt to input arrays
        - Made limited and/or circular
        - Proper integral when limited
     * Engines:
        - Add bestCheck and bestBoost
        - Minor restructoring
     * Models:
        - Minor restructoring and renaming
        - setLimits() replaced by setPrior() in RepeatingModel
        - provide for more dimensions of outputs in derivative
     * Problems:
        - toString() method restructured
     * Walker and WalkerList:
        - Add logPrior attribute
        - Change in inheritance reporting
     * PhantomCollection:
        - getList() method
     * NestedSampler:
        - Add repiter attribute: report every repiter when verbose=2
        - Add bestBoost
     * ModelDistribution:
        - put internal sample() method in try-except block
     * Tools:
        - subclassof() method
        - printclass finetuning
     * Test and documentation. Update.




  1. [History](#history)
  2. [Setup](#setup)
  3. [Structure](#structure)
  4. [Status](#status)
  5. [Versions](#versions)

  <a name="history"></a>


  The BayesicFitting package is a python version of the the fitter classes
  in Herschel Common Science System (HCSS). HCSS was the all encompassing
  software system for the operations and analysis of the ESA satelite
  Herschel. The HCSS version was written
  in JAVA mostly by me. I encoded features and classes that were requested
  by my Herschel colleagues or that I remembered having used myself during
  my lifelong career as data analyst for earlier satellites as IRAS, ISO
  and AKARI. So most of the stuff in here was needed and used at a certain
  moment in time. Even now the package is developing in directions that
  are needed by my work for the James Webb Space Telescope (JWST).

  The HCSS system is in the public domain under GPL3. It was used by the 3
  instrument groups of the Herschel satellite to write calibration and
  analysis software. Since the end of the mission HCSS is not being
  maintained

  I used a customized version of java2python (j2py on github) to translate
  the JAVA classes to python. However, the actual code needed serious
  pythonization. Every line has been inspected. Every construct has been
  revised.

  The documentation got most profit from the automated conversion. Also
  the structure into classes, the inheritance, methods and dependencies
  are largely the same as in the original HCSS.

  <a name="setup"> </a>


  The package is written in python3 although I am not aware of using any
  specific python3 features. It uses numpy (>= 1.9) for its array
  structure, scipy (>=1.0) for linear algebra and other stuff and astropy
  (>=2.0) for units. Matplotlib (>=2.0) is used for plotting.

  Download and unpack the BayesicFitting zip file from github. Move into
  the BayesicFitting-master directory and run:

      python setup.py install

  where python is python3. Or install it as :

      pip install BayesicFitting

  <a name="structure"> </a>




  The BayesicFitting package consists of over 100 classes, each class in
  its own file. These classes can be divided into 3 broad categories:
  models, fitters and nested sampling. About 50 models, 10 fitters and the
  remainder is needed to run the nested sampling algorithm. All these
  classes are in a directory BayesicFitting/source. A special type of
  functions are found in BayesicFitting/source/kernels. They can be used
  to construct a model.




  In [BayesicFitting/examples]
  (https://github.com/dokester/BayesicFitting/blob/master/BayesicFitting/examples)
  a number of scripts can be
  found to exercise the classes. They are in the form of jupyter
  notebooks. Some are using real data; others have synthetic data
  specially constructed to make some point.

  All examples can be inspected by clicking on them. They will fold out in
  the browser.

  To actually exercise the examples and maybe adapt then, start a jupyter
  notebook in your examples directory.

      jupyter notebook

  The program will open a list in your webbrowser where you can select a
  notebook file (.ipynb), which can be run.




  In the [documenation]
  (https://github.com/dokester/BayesicFitting/blob/master/docs)
  directory a number of documents can be found.


  + [Manual](https://github.com/dokester/BayesicFitting/blob/master/docs/manual.md)<br>
  A first draft of a manual. It obviously needs more work.

  + [Troubles](https://github.com/dokester/BayesicFitting/blob/master/docs/troubles.md)<br>
  A list of troublesome situations and what to do about it.

  + [Glossary](https://github.com/dokester/BayesicFitting/blob/master/docs/glossary.md)<br>
  A list of the terms used throughout this package, with explanations.

  + [Design](https://github.com/dokester/BayesicFitting/blob/master/docs/design.md)<br>
  An architectural design document, displaying the relationships between
  the classes.

  + [Style](https://github.com/dokester/BayesicFitting/blob/master/docs/code-style.md)<br>
  A few notes on my style of code and documenation.

  + [References](https://github.com/dokester/BayesicFitting/blob/master/docs/references.md)<br>
  A list of external references for BayesicFitting.



  Almost all classes have a test harness. These are located in
  BayesicFitting/test. They can be execised as:

      python -m unittest <file>

  where python refers to python3 and file refers to one of the files in
  BayesicFitting/test.<br>
  As most functionality is tested in a test harness, examples on how to
  use the classes can be found there too.

  <a name="status"> </a>


  A package like this is never finished. Always more classes and/or
  functionalities can be added. I present it now as it is in the hope it
  will be usefull and it will generate feedback.

  According to Wikipedia -> "Software release life cycle" it is called
  "Perpetual Beta". It continues to be in a beta-release because new
  classes and features can be added.

  Some of the newer additions will be indicated as having and "Alpha"
  status and keep that until they ripened somewhat further.
  The classes are more prone to change in their interfaces, methods etc.

  More work needs to be done in:

    * Introduction of more Classes: NeuralNetModel, ...

  <a name="versions"></a>


   +  4 Jan 2018 version 0.9.0.<br>
     * Initial upload to github.

   + 26 Jan 2018 version <br>

   +  5 Mar 2018 version 1.0.1 <br>
     * Package on pypi.com.
     * Restructured all import statement to comply with PYPI package.

   + 14 Mar 2018 version 1.0.2 <br>
     * Added Dynamic Models
     * Added piping of models

   + 23 Mar 2018 version 1.0.3 <br>
     * Some issues with ErrorDistributions and map fitting
     * 2-d fitting examples added
     * All examples revisited
     * Links in README.md updated

   + 28 May 2018 version 1.0.4 <br>
     * New classes: CircularUniformPrior, PseudoVoigtModel
     * VoigtModel uses scipy.special.wozf() and has partials now,
     * Refactoring Priors to the BaseModel
     * Restructuring Dynamic
     * Threading optional in NestedSampler.
     * New classes: UniformErrorDistribution, FreeShapeModel and kernels/Tophat
     * added to testharnesses and examples

   + 27 June 2018 version 1.0.5<br>
     * New classes: RadialVelocityModel and MixedErrorDistribution
     * testharnesses and examples
     * documentation updates

   + 28 June 2018 version 1.0.6
     * longdescription set to markdown (Still not OK on pypi.org)

   + 28 July 2018 version 1.0.7
     * small compilation error in 1.0.6

   + 11 October 2018 version 1.0.8
     * refactoring the setting of attributes in Models
     * documentation (manual, design, etc.) updated.

   + 28 December 2018 version 2.0.0
     * Introduction of Problem Classes:
       - Problem. <br>
  	Base class for problems to be handled by NestedSampler.
       - ClassicProblem. <br>
  	Common class for everything that was possible in version 1.
  	ClassicProblem is transparant as all interfaces to NestedSampler have remained
  	the same as they were in version 1.0, even though behind the scenes a
  	ClassicProblem has been invoked.
       - ErrorsInXandYProblem. <br>
  	Problem that have errors in the xdata  and in the ydata.
       - ... more to come.
     * Introduction of Walker and WalkerList to represent the internal ensemble
       in NestedSampler.
     * Adaptations in NestedSampler, ErrorDistributions, Engines, Sample, SampleList.
     * Better separation of responsibilities of ErrorDistribution and Problem. <br>
       Consequently ErrorDistribution has a new initialisation, which is incompatible
       with previous versions. In most cases this has no effect on the calling
       sequences of NestedSampler.
     * Rename GenGaussErrorDistribution into ExponentialErrorDistribution.
     * New testharnesses and examples.
     * Adaptations of documentation: manual and design.

   + 16 Jan 2019 version 2.1.0
     * MultipleOutputProblem.
       Problems with more dimensional outputs
     * StellarOrbitModel.
       A 2 dim output model to calculate the orbit of a double star
     * Keppler2ndLaw.
       To calculate the radius and true anomaly according to Kepplers 2nd law.
       (and derivatives)
     * RadialVelocityModel: adapted to Kepplers2ndLaw. A slight change in the
       order of the parameters.
     * NestedSampler: some improvements in output layout.
     * New tests, examples and updates for documentation.

   + 7 Feb 2019 version 2.2.0
     * ChordEngine. Implementation of the POLYCHORD engine, developed
       by Handley etal. (2015) MNRAS
     * OrthogonalBasis. Helper class fot ChordEngine.
     * Tests and examples

   + 19 Feb 2019 version 2.2.1
     * AmoebaFitter still mentioned GenGaussErrorDistribution; replaced
       by ExponentialErrorDistribution
     * Some documentation issues repaired.

   + 20 Jun 2019 version 2.3.0
     * Add LogisticModel and SampleMovie
     * Periodic residuals in Problem
     * Small issues repaired
     * Rerun all examples
     * Pictures moved to documentation/images
     * Some documentation issues repaired.

   + 14 Nov 2019 version 2.4.0 to 2.4.2
     * New Classes:
        - DecisionTreeModel
  	A DecisionTree Model (DTM) is mostly defined on multiple input dimensions (axes).
      	It splits the data in 2 parts, according low and high values on a certain input axis.
      	The splitting can continue along other axes.
        - Modifiable
  	Interface to define modifiable behaviour of some Models.
        - StructureEngine
  	Engine to modify Models that implement Modifiable
     * Introduce Table from astrolib as (multidimensional) xdata
     * Some restructering necessitated by the classes above.
     * Testcases and examples for the classes above

   + 3 Feb 2020 version 2.4.3
     * Clean up and unification of the python doc strings.
     * Reran all examples and test harnasses in python 3.7.
     * Add random seed to several examples to make them more stable.

   + 17 Mar 2020 version 2.4.4
     * Moved BayesicFitting/BayesicFitting/documentation to BayesicFitting/docs
     * Added a references.md file which collects (external) references.
     * Updated the docs files.
     * Handling of weight in accordance with the definition in the Glossary.
     * Add keyword tail= to formatter to display last items of an array.

   + 4 Jun 2020 version 2.5.0
     * Add new models: BasicSplinesModel and SplinesDynamicModel
     * Option for constraints on the likelihood
     * Option for slow engines (working every slow-th iteration in NestedSampler)
     * Restructure growPrior setting
     * Print formatting in NestedSampler
     * Adapt to SplinesDynamicModel
     * Homogenized and improved plotoptions in test harnesses
     * Three more examples added

   + 5 Jun 2020 versions 2.5.1
     * Comment out NeuralNetModel (not yet available) and some typos.

   + 6 Jun 2020 versions 2.5.2
     * Two more bugs smashed (in StartEngine and Prior)

   + 29 Jun 2020 versions 2.5.3
     * Averaging of circular variables
     * Update of static class attributes
     * Attribute and printing issues.

   + 23 Oct 2020 version 2.6.0
     * New class: PhantomSampler; adaptations in Engines, Explorer, WalkerList
     * Restructured NestedSampler to accommodate PhantomSampler
     * Test harnass for PhantomSampler
     * Option: fix parameters in BasicSplinesModel
     * Confusing __str__ method in compound models improved

   + 6 Nov 2020 versions 2.6.1
     * Avoid infinities in unbound Priors
     * mcycles in initialization of MonteCarlo
     * convert xdata, ydata, weights using numpy.asarray

   + 11 Dec 2020 versions 2.6.2
     * Add limits and circular to Priors
     * Finetune Engines

   + 18 Feb 2021 version 2.7.0
     * New class: EvidenceProblem & ModelDistribution; adaptations in NestedSampler and tests.
     * Change in constrain method definition
     * decay in ExpModel
     * some seldom errors, clean-up & new test harnasses.

   + 19 April 2021 version 2.7.1
     * remove CrossEngine completely

   + 20 April 2021 version 2.7.2
     * put some tests on hold
     * few minor issues/errors

   + 29 Oct 2021 version 2.8.0
     * New class: BernoulliErrorDistribution and SoftMaxModel, tests, examples and data
     * Adaptations To BernoulliED in some other classes
     * Multi-dim input and output issues
     * Updated some other tests and examples
     * Documentation and other small issues.

   + 25 Nov 2021 version 2.8.1
     * Cleanup in Plotter
     * Documentation issues; Replaced style.md by code-style.md
     * Correcting error on Windows systme

   + 07 Feb 2022 version 3.0.0
     * New classes: AstropyModel and UserModel
     * New class: NeuralNetUtilities
     * New classes: NestedSolver, OrderProblem, SalesmanProblem, DistanceCostFunction
     * New classes: OrderEngine, MoveEngine, SwitchEngine, LoopEngine, ShuffleEngine
     * New classes: ReverseEngine, NearEngine, StartOrderEngine
     * Make pipe work for more dimensional output | input
     * Test harnesses for the new classes
     * New examples for AstropyModel, UserModel and SalesmanProblem
     * Update existing examples to improve coverage of pytest
     * update Manual

   + 05 Apr 2022 version 3.0.1
     * Addressing issue #18: UserModel does not work for multiple dimensions.

   + 19 Nov 2022 version 3.1.0
     * Gauss2dErrorDistribution: New Class to handle correlated errors in X and Y
     * ErrorDistribution and GaussErrorDistribution : adaptation for covariant errors.
     * Small updates and corrections and removal of unused methods
     * Added / corrected version information and documentation issues
     * Rerun all examples and added tests

   + 18 Jan 2023 version 3.1.0 (still working on the same update)
     * Implementing accuracy in fitters and samplers
     * Update of documentation
     * More tests

   + 18 Jan 2023 version 3.1.1
     * remove GaussPriorNew from __init__.py

   + 31 Aug 2023 version 3.2.0
     * The new class, PhantomCollection is part of NestedSampler. It contains a sorted
       WalkerList, in which all valid positions are collected, proper walkers
       and phantoms. Each iteration the phantoms with log likelihood lower than the
       low limit for that iteration, are removed. The PhantomCollection is used
       to get a better estimate on the size of the bounding box for the  walkers and
       to obtain starting positions for new walkers. In general the PhantomCollection
       contains an order of magnitude more items than the WalkerList itself.
     * NestedSampler has a new stopping criterion. It also stops when the log of the
       relative contribution to the logZ (evidence) integral is less than -tolerance (=12).
     * FootballModel: new class. Model to estimate strengths of football teams in
       several key parameters.
     * Address PhantomCollection and add **kwargs in all Engines
     * Quadratic (in stead of linear) interpolation on edge in GalileanEngine
     * Unnormalized Gauss prior changed into a normalized one
     * Some documentation issues
     * More dimensional arrays in LogFactorial
     * __str__() method in NestedSolver and PhantomSampler
     * Avoid numeric instabilities in sqrt in SampleList
     * New tools in Tools
     * More construction options in WalkerList
     * New example: Uefa2022.ipynb
     * New tests: TestPhantomCollection, TestFootballModel
     * Adaptations in existing tests
     * Reran all tests and examples

   + 20 March 2024 version 3.2.1
     * See above in Whats new




  <br><br><br><br>


pkgId: d4a8e91ef5011775171d7b5646e456a791bdcef1dc9600729928a8b86808408b
name: python-BcdaMenu
arch: src
version: 2019.5.0
epoch: 0
release: 1
summary: A GUI menu button to start common software.
url: http://BcdaMenu.readthedocs.io
rpm_license: (c) 2009-2019, UChicago Argonne, LLC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BcdaMenu-2019.5.0-1.src.rpm
checksum_type: sha256
description:
  bcdamenu


  Creates a GUI menu button to start common beam line software

  Provides


  * **bcdamenu**       : the button menu

  Package Information


  * **author**        Pete R. Jemian
  * **email**         jemian@anl.gov
  * **copyright**     2009-2019, Pete R. Jemian
  * **license**       ANL OPEN SOURCE LICENSE (see `LICENSE.txt <http://BcdaMenu.readthedocs.io/en/latest/license.html>`_ file)
  * **documentation** http://bcdamenu.readthedocs.io
  * **source**        https://github.com/BCDA-APS/bcdamenu

  * **release badges**
     .. image:: https://img.shields.io/pypi/pyversions/bcdamenu.svg
        :target: https://pypi.python.org/pypi/bcdamenu
        :alt: PyPI version
     .. image:: https://img.shields.io/github/tag/BCDA-APS/bcdamenu.svg
        :target: https://github.com/BCDA-APS/bcdamenu/tags
        :alt: https://github.com/BCDA-APS/bcdamenu/tags
     .. image:: https://img.shields.io/github/release/BCDA-APS/bcdamenu.svg
        :target: https://github.com/BCDA-APS/bcdamenu/releases
        :alt: https://github.com/BCDA-APS/bcdamenu/releases
     .. image:: https://img.shields.io/pypi/v/bcdamenu.svg
        :target: https://pypi.python.org/pypi/bcdamenu/
        :alt: https://pypi.python.org/pypi/bcdamenu/
     ..
        .. image:: https://anaconda.org/BCDA-APS/bcdamenu/badges/version.svg
           :target: https://anaconda.org/BCDA-APS/bcdamenu


pkgId: 1ad7ce24e70d8c02cf602eab8fd2bce792d39d9acb711570ce1c2f4fb85e185f
name: python-Bcrypt-Flask
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Brcrypt hashing for Flask.
url: https://github.com/mahenzon/flask-bcrypt
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bcrypt-Flask-1.0.2-1.src.rpm
checksum_type: sha256
description:
  [Original repo](https://github.com/maxcountryman/flask-bcrypt) gets some updates at GitHub, but new versions are not uploaded to pypi at all.
  Maintainer [declined](https://github.com/maxcountryman/flask-bcrypt/pull/66) to keep pypi project up to date.
  So here's this repo: [pypi package](https://pypi.org/project/Bcrypt-Flask/1.0.0/) is automatically updated and is in sync with the [master branch](https://github.com/mahenzon/flask-bcrypt).



  Flask-Bcrypt is a Flask extension that provides bcrypt hashing utilities for
  your application.

  Due to the recent increased prevalence of powerful hardware, such as modern
  GPUs, hashes have become increasingly easy to crack. A proactive solution to
  this is to use a hash that was designed to be "de-optimized". Bcrypt is such
  a hashing facility; unlike hashing algorithms such as MD5 and SHA1, which are
  optimized for speed, bcrypt is intentionally structured to be slow.

  For sensitive data that must be protected, such as passwords, bcrypt is an
  advisable choice.



  Install using pip:

  ```bash
  pip install Bcrypt-Flask
  ```



  To use the extension simply import the class wrapper and pass the Flask app
  object back to here. Do so like this:

  ```python
  from flask import Flask
  from flask_bcrypt import Bcrypt

  app = Flask(__name__)
  bcrypt = Bcrypt(app)
  ```

  Two primary hashing methods are now exposed by way of the bcrypt object. Use
  them like so:

  ```python
  pw_hash = bcrypt.generate_password_hash('hunter2')
  bcrypt.check_password_hash(pw_hash, 'hunter2') # returns True
  ```



  (Flask config)

  - `BCRYPT_LOG_ROUNDS`: default `12`
  - `BCRYPT_HASH_PREFIX`: default `'2b'`
  - `BCRYPT_HANDLE_LONG_PASSWORDS`: default `False`.
  By default, the bcrypt algorithm has a maximum password length of 72 bytes
  and ignores any bytes beyond that. A common workaround is to hash the
  given password using a cryptographic hash (such as `sha256`), take its
  hexdigest to prevent NULL byte problems, and hash the result with bcrypt.
  If the `BCRYPT_HANDLE_LONG_PASSWORDS` configuration value is set to `True`,
  the workaround described above will be enabled.
  **Warning: do not enable this option on a project that is already using
  Flask-Bcrypt, or you will break password checking.**
  **Warning: if this option is enabled on an existing project, disabling it
  will break password checking.**



  https://bcrypt-flask.readthedocs.io/en/latest/


pkgId: 83c199448a00b2f2b1e13f1b2287639e4cae3202cadbed4cc5d9b7261e062307
name: python-BeanCommonUtils
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: A Python library for common methods.
url: https://github.com/beansKingdom/CommonUtils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BeanCommonUtils-1.1.7-1.src.rpm
checksum_type: sha256
description:
  1. 淇敼setup涓殑鐗堟湰

  2. python setup.py sdist build

  3. twine upload --skip-existing dist/*




  pip鐨勪竴浜涙搷浣


  pip install --upgrade BeanCommonUtils


  pip install -r requirements.txt


  pip freeze > requirements.txt



  淇敼鏃ュ織宸ュ叿


  date_utils add compute_special_time_timestamp 鎸夋寚瀹氭牸寮忕殑鏃堕棿鐨勫瓧绗︿覆鍏ュ弬, 杩斿洖瀹冪殑鏃堕棿鎴(绮惧害姣)


pkgId: d2cc8b3d53e99e0484a9225bcfb21a5b45ad9267117be50e8437d62f5412eeae
name: python-BeautifulReport
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: unittest自动化测试的可视化报告模板
url: https://github.com/mocobk/BeautifulReport
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BeautifulReport-0.1.3-1.src.rpm
checksum_type: sha256
description:
  一个基于unittest.TestResult模块实现的测试用例模板, 可把测试中的结果通过BeautifulReport整合成一个可视化的报表.



  ```shell
  >>> pip install BeautifulReport
  ```


  ```python

  import unittest
  from BeautifulReport import BeautifulReport

  if __name__ == '__main__':
      test_suite = unittest.defaultTestLoader.discover('./tests', pattern='test*.py')
      result = BeautifulReport(test_suite)
      result.report(filename='测试报告', description='测试deafult报告', report_dir='report', theme='theme_default')

  ```



  * BeautifulReport.report
      * report (
          filename -> 测试报告名称, 如果不指定默认文件名为report.html
          description -> 测试报告用例名称展示
          report_dir='.' -> 报告文件写入路径
          theme='theme_default' -> 报告主题样式 theme_default theme_cyan theme_candy theme_memories
      )

  * BeautifulReport.add_test_img

  如果使用报告过程中需要把测试报告的截图放在报告中, 可以使用add_test_img方法

  * add_test_img (
      *pargs
  )

  可以在测试用例上挂载一个装饰器, 实例内容如下


  * 默认存放的图片路径是img, 需要在当前测试项目的启动路径下, 创建一个img文件夹
  * 传递给装饰器的图片,在运行测试前可以不存在, 运行测试之后生成即可.
  * 当文件在报告中展示后, 想要看到原图, 可以点击报告中的缩略图查看完整的截图

  ```python
  import unittest
  from BeautifulReport import BeautifulReport


  class UnittestCaseSecond(unittest.TestCase):
      """ 测试代码生成与loader 测试数据"""

      def test_equal(self):
          """
          test 1==1
          :return:
          """
          import time
          time.sleep(1)
          self.assertTrue(1 == 1)

      @BeautifulReport.add_test_img('测试报告.png')
      def test_is_none(self):
          """
          test None object
          :return:
          """
          save_some_img('测试报告.png')
          self.assertIsNone(None)
  ```

  * 运行sample之后生成如下报告

  ![image](http://mocobk.test.upcdn.net/image/img20190325125101.jpg)

  * 主题样式

  ![image](http://mocobk.test.upcdn.net/image/img20190325124850.jpg)

  感谢原作者 [TesterlifeRaymond](https://github.com/TesterlifeRaymond/BeautifulReport) 的代码贡献，本人在原基础上修复了部分bug并增加了主题样式的自定义


pkgId: 5b6bc26403a5199319b09e70593e09215e6f61c76777cb83abf0c669fcbc2850
name: python-BenBotAsync
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Asynchronous Python wrapper for BenBot API.
url: https://github.com/xMistt/BenBot
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BenBotAsync-3.0.2-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for the BenBot API.

  [![Downloads](https://pepy.tech/badge/benbotasync)](https://pepy.tech/project/benbotasync)
  [![Requires: Python 3.x](https://img.shields.io/pypi/pyversions/BenBotAsync.svg)](https://pypi.org/project/BenBotAsync/)
  [![BenBot Version: 1.0.1](https://img.shields.io/pypi/v/BenBotAsync.svg)](https://pypi.org/project/BenBotAsync/)



  ~~Windows:~~ ``py -3 -m pip install BenBot``<br>
  ~~Linux/macOS:~~ ``python3 -m pip install BenBot``


  Windows: ``py -3 -m pip install BenBotAsync``<br>
  Linux/macOS: ``python3 -m pip install BenBotAsync``


  ```py
  import BenBotAsync
  import asyncio


  async def ben_search():
      result = await BenBotAsync.get_cosmetic(
          lang="en",
          searchLang="en",
          matchMethod="full",
          name="Ghoul Trooper"
      )

      print(result.id)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(ben_search())

  ```

  This would output:<br>
  ```CID_029_Athena_Commando_F_Halloween```

  fortnitepy example:
  ```py
  import fortnitepy
  import BenBotAsync


  client = fortnitepy.Client(
      auth=fortnitepy.EmailAndPasswordAuth(
          email='example@email.com',
          password='password123'
      )
  )


  @client.event
  async def event_friend_message(message: fortnitepy.FriendMessage) -> None:
      args = message.content.split()
      split = args[1:]
      content = " ".join(split)

      if args[0] == '!skin':
          skin = await BenBotAsync.get_cosmetic(
              lang="en",
              searchLang="en",
              matchMethod="contains",
              name=content,
              backendType="AthenaCharacter"
          )

          await client.user.party.me.set_outfit(asset=skin.id)


  client.run()

  ```

  You can check out the documentation for BenBotAsync [here](https://stoplight.io/p/docs/gh/xMistt/BenBotAsync).


pkgId: acaf12134c697d7f23d290afbc35cad8288da53700ae2f6afe0cecd74ed6fb9a
name: python-BenToTru
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/fms-1988
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BenToTru-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  Estimation of GHG emissions based on energy consumption in Brazil, broken down by 51 and 68 distinct activities.

description:
  Este pacote estima as emissões de determinados gases de efeito estufa (CO2, CH4, N2O, NOx, CO e SO2) geradas pelo consumo de energia no Brasil. Ele utiliza os dados anuais de consumo de energia fornecidos pela Empresa de Pesquisa Energética (EPE) e os fatores de emissão fornecidos pelo IPCC (revisão de 1996) e adaptados pela ONG Economia e Energia (E&E) para as condições brasileiras. O resultado são as emissões por setor econômico (estrutura IPCC) e por produto (diesel, eletricidade, álcool, etc).

  Além de estimar as emissões para os 22 setores, o pacote também desagrega essas emissões em 51 ou 68 setores (de acordo com a estrutura do IBGE). Para realizar essa desagregação, utilizamos uma adaptação do método de Montoya et al. (2013), que é descrita [aqui](https://brsa.org.br/wp-content/uploads/wpcf7-submissions/30290/artigo_desagregacao_identificado.pdf).

  Para a estrutura baseada em 51 setores, temos dados que abrangem de 2000 a 2022. Para a estrutura baseada em 68 setores, os dados disponíveis cobrem o período de 2010 a 2022. Além dos dados relacionados aos setores econômicos, também incorporamos informações sobre as emissões atribuídas às famílias. Uma descrição detalhada das funções é fornecida nas seções a seguir.


  A versão mais recente do pacote BenToTru é 0.1.0. O módulo principal, que também é o mais rápido porque utiliza operações matriciais em vez de laços, é o 'btt'.

  ```python
  pip install BenToTru==0.1.0
  from BenToTru import btt as btt
  ```


  A função `import_data_tru()` importar dados de consumo intermediário (CI) da Matriz de Recursos e Usos (TRU) do Brasil. O objetivo é diferenciar entre setores econômicos (ben) e atividades (tru), sendo que os setores TRU são denominados "atividades". O código configura o ano de referência como 2020, define 51 atividades, especifica que os dados estão a preços correntes (`u = 't'`) e utiliza 2014 como ano-base para a deflação. O parâmetro `household` indica se as famílias serão incluídas na análise. O resultado importado contém duas tabelas: uma com todos os produtos (dimensão 51x107) e outra com produtos que emitem gases de efeito estufa (dimensão 51x17).

  ```python





  ano = '2020'      # ano de referência dos dados
  N = '51'          # número de atividade (51 ou 68)
  u = 't'           # (t:preços correntes ou t1:do ano anterior)
  ano_base = '2014' # ano base para a deflação
  household=False   # considerar, ou não, as famílias na análise

  TRU51 = btt.import_data_tru(ano, N, u, ano_base, household)
  TRU51[0] # CI com todos os produtos      (51, 107)
  TRU51[1] # CI de produtos que emitem GHG (51, 17)
  ```

  Não se preocupe com a variável `u` por equanto. Sua função está relacionada à criação de coeficientes de distribuição ('t': considera preços correntes, 't1': considera preços do ano anterior).




  A função `import_data_ben()` importar dados do Balanço Energético Nacional (BEN), que estão na unidade de mil toneladas equivalentes de petróleo (10³ tep). O ano de referência dos dados é 2020 e o número de atividades econômicas é definido como 51. A matriz completa do BEN contém 20 setores e 27 produtos, enquanto a matriz reduzida, que foca apenas em produtos que emitem gases de efeito estufa (GHG), tem 20 setores e 17 produtos. O código organiza esses dados em duas matrizes: uma completa e outra filtrada para análise de emissões.

  ```python



  ano = '2020'      # ano de referência dos dados
  N = '51'          # número de atividades (51 ou 68)



  ben = btt.import_data_ben(ano, N)
  ben[0] # matriz completa   (20, 27)
  ben[1] # matriz reduzida (apenas com produtos que geram GHG) (20, 17)

  ```



  A função `import_dictionaries()` importar os dicionários que fazem a correspondência entre setores do Balanço Energético Nacional (BEN) e as atividades da Matriz de Recursos e Usos (TRU). O dicionário `dict1` contém duas estruturas: `dict1[0]`, que relaciona os produtos do BEN com as atividades do TRU, e `dict1[1]`, que relaciona os setores do BEN com as atividades do TRU. Esses dicionários são essenciais para realizar análises que integram as duas bases de dados.

  ```python


  dict1 = btt.import_dictionaries('51')


  ```


  A função `btt.emission()` retorna várias estruturas de dados, incluindo: a matriz completa de consumo energético do BEN (20 setores, 27 produtos), a matriz reduzida com produtos que geram GHG, as emissões na matriz TRU (`N` atividades, 17 produtos), as emissões ajustadas com dados do Sirene, e o coeficiente de distribuição. Além disso, o código também importa dicionários que conectam os setores do BEN com as atividades da TRU.

  ```python


  ano = '2020'      # ano de referência dos dados
  N = '51'          # número de atividades (51 ou 68)
  u = 't'           # (t:preços correntes ou t1:do ano anterior)
  ano_base = '2014' # ano base para a deflação
  gas='CO2'         # tipo de GHG (CO2, NH4 ou N2O)
  household=False   # considerar, ou não, as famílias na análise

  E = btt.emission(ano,N,u,ano_base,gas,household)

  ben = E[3][0]      # (20, 27)  (10³ tep)     matriz completa
  ben_red = E[3][1]  # (20, 17)  (10³ tep)     matriz reduzida (apenas com produtos que geram GHG)
  E_tru = E[0]       # (51, 17)  (Gg of GHG)   emissões no formato da matriz TRU
  E_tru_adj = E[4]   # (51, 17)  (Gg of GHG)   emissões ajustadas (regressão com os dados sirene)
  coef1 = E[1]       # (51, 17)  (BRL/BRL)
  ben_to_tru = E[2]  # dicionarios
  ```

  A função `btt.verification(N, coef1)` valida os coeficientes para o caso com N atividades econômicas, comparando a soma dos valores para garantir que estejam dentro dos padrões esperados. O tamanho da matriz resultante é (12, 17), o que indica 12 setores ou atividades e 17 produtos ou categorias relacionadas.

  ```python


  btt.verification(N,coef1) # (12, 17)
  ```




  A função `map_ben_to_tru()` mapeia a relação entre os setores do Balanço Energético Nacional (BEN) e os setores da Matriz de Recursos e Usos (TRU).

  ```python


  j = 1 #sector ‘SETOR ENERGÉTICO’
  i = 1 #product ‘CARVÃO VAPOR’
  btt.map_ben_to_tru(N,E_tru,j,i)[0]
  ```



  A função `btt.tru.read_var_def()` pode ser usada para importar uma variável específica da tabela TRU. No exemplo, a variável `OT_pm` (Oferta total a preço de mercado) é selecionada para o ano de `ano=2020`, considerando `N=12` atividades econômicas.

  ```python


  ano = '2020'  # ano de referência dos dados
  N = '12'      # número de atividades (51, 68, 20 ou 12)
  var = 'OT_pm' # (consulte a tabela de variáveis disponíveis no final do arquivo)
  u = 't'       # (t:preços correntes ou t1:do ano anterior)
  ano_base = '2014' # ano base para a deflação
  OT_pm = btt.tru.read_var_def(ano,N,var,u,ano_base)
  ```

  | var         | sheet      | type   | description                                                                        |
  |-------------|------------|--------|------------------------------------------------------------------------------------|
  | OT_pm       | oferta     | vector | Oferta total a preço de consumidor                                                  |
  | MG_com      | oferta     | vector | Margem de comércio                                                                 |
  | MG_tra      | oferta     | vector | Margem de transporte                                                               |
  | L_imp       | oferta     | vector | Imposto de importação                                                              |
  | IPI         | oferta     | vector | IPI                                                                                |
  | ICMS        | oferta     | vector | ICMS                                                                               |
  | OI_liq_Sub  | oferta     | vector | Outros impostos menos subsídios                                                    |
  | TI_liq_sub  | oferta     | vector | Total de impostos líquidos de subsídios                                            |
  | OT_pb       | oferta     | vector | Oferta total a preço básico                                                        |
  | P_matrix    | producao   | matrix | Produção das atividades                                                            |
  | PT          | producao   | vector | Total do produto                                                                   |
  | CIF_FOB     | importacao | vector | Ajuste CIF/FOB                                                                     |
  | M_bens      | importacao | vector | Importação de bens                                                                 |
  | M_serv      | importacao | vector | Importação de serviços                                                             |
  | CI_matrix   | CI         | matrix | Consumo intermediário das atividades                                               |
  | D_ci        | CI         | vector | Total do produto (Tabela 2 CI)                                                     |
  | X_bens      | demanda    | vector | Exportação de bens                                                                 |
  | X_serv      | demanda    | vector | Exportação de serviços                                                             |
  | C_g         | demanda    | vector | Consumo da administração pública                                                   |
  | C_ong       | demanda    | vector | Consumo das ISFLSF                                                                 |
  | C_f         | demanda    | vector | Consumo das famílias                                                               |
  | FBKF        | demanda    | vector | Formação bruta de capital fixo                                                     |
  | DE          | demanda    | vector | Variação de estoque                                                                |
  | D_final     | demanda    | vector | Demanda final                                                                      |
  | D_total     | demanda    | vector | Demanda total                                                                      |
  | VA_table    | demanda    | table  | Componentes do valor adicionado                                                    |
  | M_bens_serv | importacao | vector | Importação de bens e serviços (1) (1) Importação de bens e serviços líquida de ajuste CIF/FOB. |
  | X_bens_serv | demanda    | vector | (1) Importação de bens e serviços líquida de ajuste CIF/FOB.                       |




  O que realmente nos interessa é a série temporal que ilustra a evolução das emissões geradas por uma atividade específica da TRU. O código abaixo demonstra como obter e representar visualmente essa série.

  ```python
  import pandas as pd
  df = btt.emission('2010','51',u,ano_base,gas,True)[4]
  df['year'] = '2010'
  for t in ['2011','2012','2013','2014','2015','2016','2017','2018','2019','2022']:
     try:
         df_ = btt.emission(t,N,u,ano_base,gas,True)[4]
         df_['year'] = t
         df = pd.concat([df, df_])
     except:
         print('error')
  ```
  ```python
  import matplotlib.pyplot as plt

  df_h = df[df.index == 'RESIDENCIAL']

  df_h.plot(x='year', y='GÁS NATURAL', marker='o', linestyle='-')
  plt.title("Emission of CO2 by households from the consumption of natural gas.")
  plt.xlabel("Year")
  plt.ylabel("Gg of GHG")
  plt.grid(True)
  plt.show()
  ```

  ![Alt text](https://raw.githubusercontent.com/fms-1988/datas/main/chart_BenToTru.png)



  To simplify the communication of the amount of GHGs emitted, the standard unit used is CO2 equivalent emissions (CO2e). The amount of GHG released can be converted into CO2e using the Global Warming Potential (GWP) metric published in the Second Assessment Report (SAR) by the IPCC (1995).
  Brazil adopts this measurement to report its emissions, as per Decree no. 9,578/2018. The sixth emissions report provides the conversion table between GHG and CO2e (MCTI, 2022).


  | gas   	| GWP 100 years (SAR) | GWP 100 years (AR5) | GTP 100 years (AR5) |
  |-----------|--------------------|--------------------|--------------------|
  | CO2   	| 1              	| 1              	| 1              	|
  | CH4   	| 21             	| 28             	| 4              	|
  | CH4 fossil| 21             	| 30             	| 6              	|
  | N2O   	| 310            	| 265            	| 234            	|
  | HFC-23	| 11,700         	| 12,400         	| 12,700         	|
  | HFC-32	| 650            	| 677            	| 94             	|
  | HFC-125   | 2,800          	| 3,170          	| 967            	|
  | HFC-134a  | 1,300          	| 1,300          	| 201            	|
  | HFC-143a  | 3,800          	| 4,800          	| 2,500          	|
  | HFC-152   | 140            	| 16             	| 2              	|
  | CF4   	| 6,500          	| 6,630          	| 8,040          	|
  | C2F6  	| 9,200          	| 11,100         	| 13,500         	|
  | SF6   	| 23,900         	| 23,500         	| 28,200         	|



  This table is what we use to convert direct GHGs (CO2, CH4, and N2O) into equivalent amounts of CO2 (variable: CO2_GWP_SAR).



  Despite the high correlation, our data is not comparable to MCTI's data. One possible reason is that MCTI discloses its emissions in terms of the amount of carbon, while we estimate in terms of CO2. Another reason is the scale of the data presented (in tons or Gg tons). A third, more important factor, is the conversion factors used by MCTI (more up-to-date and detailed by type of fuel use).

  To solve this problem, we estimated correction coefficients for our data using official MCTI data. All coefficients and methodology are described in the methodology (here).

  Now our data of CO2 equivalent emission (btt) are in the same unit and are comparable to the official MCTI data (sirene).

  ![Alt text](https://raw.githubusercontent.com/fms-1988/datas/main/chart_compare_btt_sirene.png)

  Os cálculos estão disponíveis [aqui](https://github.com/fms-1988/BenToTru/blob/main/desagregacao_CO2e_energia.ipynb)


pkgId: 1bfa016fc7a67521124c22397e44011f889c423006cc3d6bf31ee8243a6d9cd0
name: python-BenchExec
arch: src
version: 3.25
epoch: 0
release: 1
summary: A Framework for Reliable Benchmarking and Resource Measurement.
url: https://github.com/sosy-lab/benchexec/
rpm_license: Apache-2.0 AND BSD-3-Clause AND CC-BY-4.0 AND MIT AND ISC AND LicenseRef-BSD-3-Clause-CMU
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BenchExec-3.25-1.src.rpm
checksum_type: sha256
description:
  <!--
  This file is part of BenchExec, a framework for reliable benchmarking:
  https://github.com/sosy-lab/benchexec

  SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>

  SPDX-License-Identifier: Apache-2.0
  -->





  [![Build Status](https://gitlab.com/sosy-lab/software/benchexec/badges/main/pipeline.svg)](https://gitlab.com/sosy-lab/software/benchexec/pipelines)
  [![Apache 2.0 License](https://img.shields.io/badge/license-Apache--2-brightgreen.svg)](https://www.apache.org/licenses/LICENSE-2.0)
  [![PyPI version](https://img.shields.io/pypi/v/BenchExec.svg)](https://pypi.python.org/pypi/BenchExec)
  [![DOI](https://zenodo.org/badge/30758422.svg)](https://zenodo.org/badge/latestdoi/30758422)

  **News and Updates**:
  - Successful [Google Summer of Code](https://summerofcode.withgoogle.com/) project by
    [Haoran Yang](https://summerofcode.withgoogle.com/programs/2024/projects/UzhlnEel)
    brings integration of [fuse-overlayfs](https://github.com/containers/fuse-overlayfs/) into BenchExec 3.25!
    This makes BenchExec's default directory configuration for the container mode work out-of-the-box again
    without having to pass parameters such as `--read-only-dir /`.
  - BenchExec 3.18 brings support for systems with cgroups v2!
  - We now provide an [Ubuntu PPA](https://launchpad.net/~sosy-lab/+archive/ubuntu/benchmarking) that makes installing and upgrading BenchExec easier ([docs](https://github.com/sosy-lab/benchexec/blob/main/doc/INSTALL.md#debianubuntu)).
  - An extended version of our paper on BenchExec and its background was published as open access in the journal STTT,
    you can read [Reliable Benchmarking: Requirements and Solutions](https://doi.org/10.1007/s10009-017-0469-y) online.
    We also provide a set of [overview slides](https://www.sosy-lab.org/research/prs/Latest_ReliableBenchmarking.pdf).

  > To help new or inexperienced users get started with reliable benchmarking
  > right away, we offer a [quickstart guide](doc/quickstart.md) that contains
  > a brief explanation of the issues of common setups as well as the (few)
  > steps necessary to setup and use BenchExec instead.

  BenchExec is a framework for reliable benchmarking and resource measurement
  and provides a standalone solution for benchmarking
  that takes care of important low-level details for accurate, precise, and reproducible measurements
  as well as result handling and analysis for large sets of benchmark runs.
  However, even users of other benchmarking frameworks or scripts
  can benefit from BenchExec
  by letting it perform the resource measurements and limits
  instead of less reliable tools and techniques like `time` or `ulimit`,
  and results produced by BenchExec can easily be exported for use with other tools.

  In particular, BenchExec provides three major features:

  - execution of arbitrary commands with precise and reliable measurement
    and limitation of resource usage (e.g., CPU time and memory),
    and isolation against other running processes
    (provided by [`runexec`](https://github.com/sosy-lab/benchexec/blob/main/doc/runexec.md),
    a replacement for `time` and similar tools)
  - an easy way to define benchmarks with specific tool configurations
    and resource limits,
    and automatically executing them on large sets of input files
    (provided by [`benchexec`](https://github.com/sosy-lab/benchexec/blob/main/doc/benchexec.md)
    on top of `runexec`)
  - generation of interactive tables and plots for the results
    (provided by [`table-generator`](https://github.com/sosy-lab/benchexec/blob/main/doc/table-generator.md)
    for results produced with `benchexec`)


  Unlike other benchmarking frameworks,
  BenchExec is able to reliably measure and limit resource usage
  of the benchmarked tool even if the latter spawns subprocesses.
  In order to achieve this,
  it uses the [cgroups feature](https://docs.kernel.org/admin-guide/cgroup-v2.html)
  of the Linux kernel to correctly handle groups of processes.
  For proper isolation of the benchmarks, it uses (if available)
  Linux [user namespaces](http://man7.org/linux/man-pages/man7/namespaces.7.html)
  and an overlay filesystem
  (either [kernel-based](https://www.kernel.org/doc/Documentation/filesystems/overlayfs.txt)
  or [fuse-overlayfs](https://github.com/containers/fuse-overlayfs/))
  to create a [container](https://github.com/sosy-lab/benchexec/blob/main/doc/container.md)
  that restricts interference of the executed tool with the benchmarking host.
  More information on why this is necessary and the problems with other tools
  can be found in our paper
  [Reliable Benchmarking: Requirements and Solutions](https://doi.org/10.1007/s10009-017-0469-y) (open access)
  and our [slides](https://www.sosy-lab.org/research/prs/Latest_ReliableBenchmarking.pdf)
  (starting with slide "Checklist").

  BenchExec is intended for benchmarking non-interactive tools on Linux systems.
  It measures CPU time, wall time, and memory usage of a tool,
  and allows to specify limits for these resources.
  It also allows to limit the CPU cores and (on NUMA systems) memory regions,
  and the container mode allows to restrict filesystem and network access.
  In addition to measuring resource usage,
  BenchExec can optionally verify that the result of the tool was as expected
  and extract further statistical data from the output.
  Results from multiple runs can be combined into CSV and interactive HTML tables,
  of which the latter provide scatter and quantile plots
  (have a look at our [demo table](https://sosy-lab.github.io/benchexec/example-table/svcomp-simple-cbmc-cpachecker.table.html)).

  BenchExec works only on Linux and needs a one-time setup of cgroups by the machine's administrator.
  The actual benchmarking can be done by any user and does not need root access.

  BenchExec was originally developed for use with the software verification framework
  [CPAchecker](https://cpachecker.sosy-lab.org)
  and is now developed as an independent project
  at the [Software Systems Lab](https://www.sosy-lab.org)
  of the [Ludwig-Maximilians-Universität München (LMU Munich)](https://www.uni-muenchen.de).



  - [Documentation](https://github.com/sosy-lab/benchexec/tree/main/doc/INDEX.md)
  - [Demo](https://sosy-lab.github.io/benchexec/example-table/svcomp-simple-cbmc-cpachecker.table.html) of a result table
  - [Downloads](https://github.com/sosy-lab/benchexec/releases)
  - [Changelog](https://github.com/sosy-lab/benchexec/tree/main/CHANGELOG.md)
  - [BenchExec GitHub Repository](https://github.com/sosy-lab/benchexec),
    use this for [reporting issues and asking questions](https://github.com/sosy-lab/benchexec/issues)
  - [BenchExec at PyPI](https://pypi.python.org/pypi/BenchExec)
  - [BenchExec at Zenodo](https://doi.org/10.5281/zenodo.1163552): Each release gets a DOI such that you can reference it from your publications and artifacts.



  - [Reliable Benchmarking: Requirements and Solutions](https://doi.org/10.1007/s10009-017-0469-y), by D. Beyer, S. Löwe, and P. Wendler.  International Journal on Software Tools for Technology Transfer (STTT), 21(1):1-29, 2019. [doi:10.1007/s10009-017-0469-y](https://doi.org/10.1007/s10009-017-0469-y). Journal paper about BenchExec (open access, also with a [supplementary webpage](https://www.sosy-lab.org/research/benchmarking/) and [overview slides](https://www.sosy-lab.org/research/prs/Latest_ReliableBenchmarking.pdf))
  - [CPU Energy Meter: A Tool for Energy-Aware Algorithms Engineering](https://doi.org/10.1007/978-3-030-45237-7_8), by D. Beyer and P. Wendler. In Proc. TACAS 2020, part 2, LNCS 12079, pages 126-133, 2020. Springer. [doi:10.1007/978-3-030-45237-7_8](https://doi.org/10.1007/978-3-030-45237-7_8)
  - [Benchmarking and Resource Measurement](https://doi.org/10.1007/978-3-319-23404-5_12), by D. Beyer, S. Löwe, and P. Wendler. In Proc. SPIN 2015, LNCS 9232, pages 160-178, 2015. Springer. [doi:10.1007/978-3-319-23404-5_12](https://doi.org/10.1007/978-3-319-23404-5_12)



  BenchExec is licensed under the [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0),
  copyright [Dirk Beyer](https://www.sosy-lab.org/people/beyer/).
  Exceptions are some tool-info modules
  and third-party code that is bundled in the HTML tables,
  which are available under several other free licenses
  (cf. [folder `LICENSES`](https://github.com/sosy-lab/benchexec/tree/main/LICENSES)).


  Maintainer: [Philipp Wendler](https://www.philippwendler.de)

  Contributors:
  - [Eshaan Aggarwal](https://github.com/EshaanAgg)
  - [Aditya Arora](https://github.com/alohamora)
  - [Levente Bajczi](https://github.com/leventeBajczi)
  - [Dirk Beyer](https://www.sosy-lab.org/people/beyer/)
  - [Laura Bschor](https://github.com/laurabschor)
  - [Thomas Bunk](https://github.com/TBunk)
  - [Montgomery Carter](https://github.com/MontyCarter)
  - [Po-Chun Chien](https://github.com/Po-Chun-Chien)
  - [Andreas Donig](https://github.com/adonig)
  - [Florian Eder](https://github.com/schroeding)
  - [Karlheinz Friedberger](https://www.sosy-lab.org/people/friedberger)
  - [Robin Gloster](https://github.com/globin)
  - [Sam Grayson](https://github.com/charmoniumQ)
  - Peter Häring
  - [Florian Heck](https://github.com/fheck)
  - [Chinmay Joshi](https://github.com/JawHawk)
  - [George Karpenkov](http://metaworld.me/)
  - [Mike Kazantsev](http://fraggod.net/)
  - [Hugo van Kemenade](https://github.com/hugovk)
  - [Tobias Kleinert](https://github.com/Sowasvonbot)
  - [Michael Lachner](https://github.com/lachnerm)
  - [Thomas Lemberger](https://www.sosy-lab.org/people/lemberger/)
  - [Lorenz Leutgeb](https://github.com/lorenzleutgeb)
  - [Sebastian Ott](https://github.com/ottseb)
  - Stefan Löwe
  - [Stephan Lukasczyk](https://github.com/stephanlukasczyk)
  - [Tobias Meggendorfer](https://github.com/incaseoftrouble)
  - Alexander von Rhein
  - [Alexander Schremmer](https://www.xing.com/profile/Alexander_Schremmer)
  - [Dennis Simon](https://github.com/DennisSimon)
  - [Andreas Stahlbauer](http://stahlbauer.net/)
  - [Thomas Stieglmaier](https://stieglmaier.me/)
  - [Martin Yankov](https://github.com/marto97)
  - [Hojan Young](https://github.com/younghojan)
  - [Ilja Zakharov](https://github.com/IljaZakharov)
  - and [lots of more people who integrated tools into BenchExec](https://github.com/sosy-lab/benchexec/graphs/contributors)



  Several well-known international competitions use BenchExec,
  such as [SMT-COMP](https://smt-comp.github.io/),
  [SV-COMP](https://sv-comp.sosy-lab.org) (software verification),
  the [Termination Competition](https://termination-portal.org/wiki/Termination_Competition),
  and
  [Test-Comp](https://test-comp.sosy-lab.org).
  In particular in SV-COMP
  BenchExec was used successfully for benchmarking in all instances of the competition
  and with a wide variety of benchmarked tools and millions of benchmark runs per year.
  BenchExec is also integrated into the cluster-based logic-solving service
  [StarExec](https://www.starexec.org/starexec/public/about.jsp) ([GitHub](https://github.com/StarExec/StarExec)).

  The developers of the following tools use BenchExec:

  - [CPAchecker](https://cpachecker.sosy-lab.org), also for regression testing
  - [Dartagnan](https://github.com/hernanponcedeleon/Dat3M)
  - [ESBMC](https://github.com/esbmc/esbmc), also for regression testing and even with a [GitHub action](https://github.com/esbmc/esbmc/blob/master/.github/workflows/benchexec.yml) for BenchExec
  - [SMACK](https://github.com/smackers/smack)
  - [SMTInterpol](https://github.com/ultimate-pa/smtinterpol)
  - [TriCera](https://github.com/uuverifiers/tricera)
  - [Ultimate](https://github.com/ultimate-pa/ultimate)

  If you would like to be listed here, [contact us](https://github.com/sosy-lab/benchexec/issues/new).


pkgId: 68044a669cf0b33246af7f4a81a79ccee8d82842386bcf78387b17c6b320a331
name: python-Benchmarker
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: small but awesome utility for benchmarking
url: https://pythonhosted.org/Benchmarker/
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Benchmarker-4.0.1-1.src.rpm
checksum_type: sha256
description:
  Benchmarker.py is an awesome utility for benchmarking.

          Document: https://pythonhosted.org/Benchmarker/

          Example code (example.py)::

              from benchmarker import Benchmarker

              
              with Benchmarker(1000*1000, width=20) as bench:
                  s1, s2, s3, s4, s5 = "Haruhi", "Mikuru", "Yuki", "Itsuki", "Kyon"

                  @bench(None)                ## empty loop
                  def _(bm):
                      for i in bm:
                          pass

                  @bench("join")
                  def _(bm):
                      for i in bm:
                          sos = ''.join((s1, s2, s3, s4, s5))

                  @bench("concat")
                  def _(bm):
                      for i in bm:
                          sos = s1 + s2 + s3 + s4 + s5

                  @bench("format")
                  def _(bm):
                      for i in bm:
                          sos = '%s%s%s%s%s' % (s1, s2, s3, s4, s5)

          Output Example::

              $ python example.py -h              # show help
              $ python example.py -o result.json
              
              
              
              
              
              
              

              
              (Empty)                 0.0236    0.0200    0.0200    0.0000
              join                    0.2779    0.2800    0.2800    0.0000
              concat                  0.3792    0.3800    0.3800    0.0000
              format                  0.4233    0.4300    0.4300    0.0000

              
              join                    0.2779  (100.0) ********************
              concat                  0.3792  ( 73.3) ***************
              format                  0.4233  ( 65.6) *************

              
              [01] join               0.2779   100.0   136.5   152.3
              [02] concat             0.3792    73.3   100.0   111.6
              [03] format             0.4233    65.6    89.6   100.0

          See https://pythonhosted.org/Benchmarker/ for details.


pkgId: be48f039c072f8e8270af1e4bc306f95ef77c2b34ba86281120436a9b6e8b891
name: python-BerryEasy
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A package for computing topological properties of TB models
url: https://github.com/actyner
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BerryEasy-0.2.1-1.src.rpm
checksum_type: sha256
description:
  BerryEasy is a python package developed by Alex Tyner. It expands upon the powerful pybinding code, offering functionality for computing topological properties of Pybinding instances as well as creating  Pybinding instances from the output of Wannier90.



  Computation of: Wannier center charges, Spin-resolved Wannier center charges, Nested wilson loop computations, conversion of Wannier90 output to pybinding format


pkgId: 90a085b8b7023375c49d555a0c66df095f80f53e593112a7c7e2a0f44ad889e1
name: python-Bestatic
arch: src
version: 0.0.28
epoch: 0
release: 1
summary: A simple but powerful static-site generator
url: https://pypi.org/project/Bestatic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bestatic-0.0.28-1.src.rpm
checksum_type: sha256
description:
  ![Screenshot of a comment on a GitHub issue showing an image, added in the Markdown, of an Octocat smiling and raising a tentacle.](https://raw.githubusercontent.com/tatsatb/bestatic/main/favicon_package/Bestatic_Logo_svg.svg)



  Bestatic is a simple but powerful static-site generator that you can install graphically without worrying about dependencies. It can simply turn your text files into fully functional websites and blogs.

  It is really minimal yet feature-rich. Like every other static-site generator,
  it can generate a complete website by processing a bunch of markdown files. As a result,
  it eliminates the need for server-side programming, databases, and constant security updates. The site that _Bestatic_ generates can be served from any web server or host (or even from Git-based platforms, for completely free).

  Some salient features of _Bestatic_ that are probably worth highlighting:

  -  **Blog-aware**. You can easily create your blog/news page along with your website. Customizable list pages for blog posts, reverse chronological order of posts, tags, comments (using Giscus or Disqus), URL customizations, RSS feeds - All standard good stuff are already included.


  -  **Feature-rich**. Want LaTeX support? Syntax highlighting for code? Powerful search functionality? Auto-reloading server? We have all these things out-of-the box.



  - **Flexible**. Want to configure things? Use simple yaml file. Want to use command line? Use our CLI options. Want to theme in your own way? Use standard Jinja2 templating to design freely.


  -  **Scalable**. Bestatic ultimately builds a bunch of static files. So, no need for database management, server maintenance, or constant security updates. A hassle-free way to manage large-scale websites.

  -  **Free and open-source** Of course, Bestatic is free and open-source, licensed under GNU GPL-3.0. This will remain free and open-source forever.


  -  **Simple** Making things simple for you is our goal. Be it via graphical installation, OS compatibility, dedicated quickstart, or in-depth documentation: We just want to make your Bestatic journey easy and enjoyable for the beginning!




  Want to try Bestatic? Download and install it from the [release page](https://github.com/tatsatb/bestatic/releases/latest), or [Snap store](https://snapcraft.io/bestatic), or [Flathub](https://flathub.org/apps/com.bestaticpy.bestatic), or [PyPI](https://pypi.org/project/Bestatic/).

  Detailed installation instructions, quickstart guide, and user manual are available on our [official documentation](https://www.bestaticpy.com/docs/).


pkgId: b53526658248c2f7b2f3510f7fc618ea35b6d68125df97bdd46cfe55bbe94f01
name: python-BetaBoost
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: BetaBoosting: gradient boosting with a beta function.
url: https://github.com/tblume1992/BetaBoost
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BetaBoost-0.0.5-1.src.rpm
checksum_type: sha256
description:
  A small wrapper to do Beta Boosting with XgBoost

  ```pip install BetaBoost==0.0.4```

  Initiate a BetaBoost object and fit a XgBoost model.
  Returns a XgBoost Train Object.

  Betaboosting assumes that there is some spike in the learning rate that exists which can give 'optimal' performance, a beta kernel with a floor is used for convenience.

  A quick example with some toy data.  Found this example awhile ago for learning rate decay:

  ```python
  import numpy as np
  import xgboost as xgb
  import matplotlib.pyplot as plt

  def generate_data():
      y = np.random.gamma(2, 4, OBS)
      X = np.random.normal(5, 2, [OBS, FEATURES])
      return X, y

  max_iter = 300
  eta_base = 0.2
  eta_min = 0.1
  eta_decay = np.linspace(eta_base, eta_min, max_iter).tolist()
  OBS = 10 ** 4
  FEATURES = 20
  PARAMS = {
      'eta': eta_base,
      "booster": "gbtree",
  }


  X_train, y_train = generate_data()
  X_test, y_test = generate_data()
  dtrain = xgb.DMatrix(X_train, label=y_train)
  dtest = xgb.DMatrix(X_test, label=y_test)
  evals_result = {'train': dtrain}

  progress1 = dict()
  model1 = xgb.train(
      maximize=True,
      params=PARAMS,
      dtrain=dtrain,
      num_boost_round=max_iter,
      early_stopping_rounds=max_iter,
      evals=[(dtrain, 'train'),(dtest, 'test')],
      evals_result=progress1,
      verbose_eval=False,
      callbacks=[xgb.callback.LearningRateScheduler(eta_decay)]
  )

  progress2 = dict()
  model2 = xgb.train(
      maximize=True,
      params=PARAMS,
      dtrain=dtrain,
      num_boost_round=max_iter,
      early_stopping_rounds=max_iter,
      evals=[(dtrain, 'train'),(dtest, 'test')],
      evals_result=progress2,
      verbose_eval=False,
      callbacks=[xgb.callback.LearningRateScheduler(list(np.ones(max_iter)*0.01))]
  )


  progress3 = dict()
  model3 = xgb.train(
      maximize=True,
      params=PARAMS,
      dtrain=dtrain,
      num_boost_round=max_iter,
      early_stopping_rounds=max_iter,
      evals=[(dtrain, 'train'),(dtest, 'test')],
      evals_result=progress3,
      verbose_eval=False,
      callbacks=[xgb.callback.LearningRateScheduler(list(np.ones(max_iter)*0.1))]
  )


  bb_evals = dict()
  import BetaBoost as bb
  betabooster = bb.BetaBoost(n_boosting_rounds = max_iter)
  betabooster.fit(dtrain=dtrain,
                  maximize=True,
                  params = PARAMS,
                  early_stopping_rounds=max_iter,
                  evals=[(dtrain, 'train'),(dtest, 'test')],
                  evals_result = bb_evals,
                  verbose_eval = False)

  plt.plot(progress1['test']['rmse'], linestyle = 'dashed', color = 'b', label = 'eta test decay')
  plt.plot(progress2['test']['rmse'], linestyle = 'dashed', color = 'r', label = '0.01 test')
  plt.plot(progress3['test']['rmse'], linestyle = 'dashed', color = 'black', label = '0.1 test')
  plt.plot(bb_evals['test']['rmse'], linestyle = 'dashed', color = 'y', label = 'bb test')
  plt.legend()
  plt.show()
  ```
  ![alt text](https://github.com/tblume1992/BetaBoost/blob/master/static/betaboost_test_image.png?raw=true "BB Awesome Image")

  A clear nice-ety of beta boosting is that the model's test set is one of the first models to converge and yet is resistant to overfitting.  Plotting the default beta kernel settings will show a function that starts quite small and peaks around .5 by iteration 30.  This process allows the model to make the largest jumps not when the trees are super weak (standard eta decay) or when they are too strong.

  A quick convergence and robustness to overfitting can be achieved with slight tunings of the beta kernel parameters...it's only 6 more parameters guys :)

  FAQ:

  Why a beta pdf?

  TLDR: it worked pretty well!

  Longer incohernt look at it: https://github.com/tblume1992/portfolio/blob/master/GradientBoostedTrees/3_Dynamic_GBT.ipynb


pkgId: 0adb3cfef54a4f843ed08f05e621afeef869d876161be7359376653954b334a1
name: python-Betelgeuse
arch: src
version: 1.11.0
epoch: 0
release: 1
url: https://github.com/SatelliteQE/betelgeuse
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Betelgeuse-1.11.0-1.src.rpm
checksum_type: sha256
summary:
  Betelgeuse is a Python program that reads standard Python test cases and generates XML files that are suited to be imported by Polarion importers.

description:
  Betelgeuse reads standard Python test cases and generates XML files that are
  suited to be imported by Polarion importers. Possible generated XML files are:
  * Requirement Importer XML
  * Test Case Importer XML
  * Test Run Importer XML
  The `full documentation <http://betelgeuse.readthedocs.org/en/latest/>`_ is
  available on ReadTheDocs.


pkgId: cb1faf13249ea0e15d7ac59269f2a330d1046e5a85f27a62dbe9ae01230f6133
name: python-BetterLoader
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: A better PyTorch dataloader
url: https://github.com/BinItAI/BetterLoader
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BetterLoader-0.2.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="#about-betterloader">About</a> •
    <a href="#installation">Installation</a> •
    <a href="#usage">Usage</a> •
    <a href="#development">Development</a> •
    <a href="#meta">License</a>
  </p>
  [![PyPi Badge](https://img.shields.io/pypi/dm/betterloader?style=for-the-badge)](https://pypi.org/project/BetterLoader/)
  [![PyPi Version](https://img.shields.io/pypi/v/betterloader?style=for-the-badge)](https://pypi.org/project/BetterLoader/)
  [![Github Actions Build Status](https://img.shields.io/github/workflow/status/BinItAI/BetterLoader/Build?style=for-the-badge)](https://img.shields.io/github/workflow/status/BinItAI/BetterLoader/Build?style=for-the-badge)
  [![Issues](https://img.shields.io/github/issues/binitai/betterloader?style=for-the-badge)](https://github.com/BinItAI/BetterLoader/issues)
  [![license](https://img.shields.io/github/license/binitai/betterloader?style=for-the-badge)](https://github.com/BinItAI/BetterLoader/blob/master/LICENSE.txt)


pkgId: 2e183d79b4be6fd5b5342d351492488b319795f54f11edfb6ad6dce150a0661e
name: python-BetterTkinter
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: An enhanced tkinter package with custom-styled widgets
url: https://github.com/Eldritchy/bettertkinter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BetterTkinter-1.3.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">



  Only a concept currently

  [![License](https://img.shields.io/badge/License-MIT-blue)](https://github.com/Eldritchy/BetterTkinter#license)  [![PyPi](https://img.shields.io/badge/PyPi%20Link-FFFF00)](https://pypi.org/project/BetterTkinter/)  <a href="https://github.com/D-I-Projects/BetterTkinter/blob/master/CONTRIBUTING.md"> <img src="https://img.shields.io/github/contributors-anon/Eldritchy/BetterTkinter" alt="Contributors badge" /></a> [![BetterTkinter](https://static.pepy.tech/badge/bettertkinter)](https://pepy.tech/project/BetterTkinter)

  ```pip install BetterTkinter```

  <b>Documentation : https://eldritchy.github.io/BetterTkinterDocs/</b>

  </div>


pkgId: 9be3e133a2eed60f8f1e91e9fc3a20888580f46c75bd7fc603e345598fd3e3d6
name: python-Bevy
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Python Dependency Injection made simple so you can focus on creating amazing code.
url: https://github.com/ZechCodes/Bevy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bevy-2.0.2-1.src.rpm
checksum_type: sha256
description:
  Bevy makes using *Dependency Injection* in *Python* a breeze so that you can focus on creating amazing code.


  ```shell script
  pip install bevy>2.0.0
  ```


  Put simply, *Dependency Injection* is a design pattern where the objects that your code depends on are instantiated by the caller. Those dependencies are then injected into your code when it is run.
  This promotes loosely coupled code where your code doesn't require direct knowledge of what objects it depends on or how to create them. Instead, your code declares what interface it expects and an outside framework handles the work of creating objects with the correct interface.


  Python doesn't have an actual interface implementation like many other languages. Class inheritance, however, can be used in a very similar way since subclasses will likely have the same fundamental interface as their base class.


  *Dependency Injection* and its reliance on abstract interfaces makes your code easier to maintain:
  - Changes can be made without needing to alter implementation details in unrelated code, so long as the interface isn’t modified in a substantial way.
  - Tests can provide mock implementations of dependencies without needing to rely on patching or duck typing. They can provide the mock to Bevy which can then ensure it is used when necessary.


  Bevy makes use of Python's contextvars to store a repository object global to the context. You can then use `bevy.inject` and `bevy.dependency` to inject dependencies into functions and classes.

  The `dependency` function returns a descriptor that can detect the type hints that have been set on a class attribute. It can then create and return a dependency that matches the type hints.

  The `inject` decorator allows you to use the `dependecy` function to inject dependencies into functions. Each parameter that needs to be injected should have its default value set to `dependency()` and then the `inject` decorator will intelligently handle injecting those dependencies into the function arguments based on the parameter type hints. This injection is compatible with positional only, positional, keyword, and keyword only arguments.

  **Example**
  ```py
  from bevy import inject, dependency

  class Thing:
      ...

  class Example:
      foo: Thing = dependency()

  @inject
  def example(foo: Thing = dependency()):
      ...
  ```
  Each dependency once created is stored in the context global repository's cache to be reused by other functions and classes that depend on them. This sharing is very useful for database connections, config files, authenticated API sessions, etc.

  **Setting Values In the Repository**

  It is possible to provide a value to the context's global repository that will be used as a dependency.You can get the current repository using the `bevy.get_repository` function, you can then use that repository's `set` method to assign an instance to a given key.
  ```python
  from bevy import get_repository

  get_repository().set(Thing, Thing("foobar"))
  ```
  This would cause anything that has a dependency for `Thing` to have the instance `Thing("foobar")` injected.

  The `set` method will return an empty `bevy.options.Value` object if it succeeds in setting the value into the cache or will return a `bevy.options.Null` object if it fails.

  **Getting Values From the Repository**

  It is possible to get values directly from the repository using its `get` method.
  ```python
  from bevy import get_repository

  thing = get_repository().get(Thing)
  ```
  If an instance of `Thing` is not found in the cache it will create an instance, save it in the cache for future use, and then return it.

  It is possible to get a value from the cache without creating an instance if it's not found using the `find` method. This method returns an `Option` type that can either be your value wrapped in a `Value` type or a `Null` type if the value was not found. You can use the `value_or` method to get your value or a default if it doesn't exist.
  ```python
  thing = get_repository().find(Thing).value_or(None)
  ```
  It is also possible to use match/case to unwrap the value with more flexibility.
  ```python
  from bevy.options import Value, Null

  match get_repository().find(Thing):
      case Value(value):
          thing = value
      case Null():
          raise Exception("Could not find an instance of Thing")
  ```

  **Dependency Providers**

  To make Bevy as flexible as possible, it has dependency providers. These are classes that can be registered with the repository to cache value instances, look up cached instances using a key type, and create new instances for a key type.

  The default repository type has two dependency providers: an annotated provider and a type provider.
  - The **Type Provider** handles key types that are class types. So when a dependency annotation is `Thing`, for example, the type provider will handle looking through its cache for an instance of `Thing` and creating an instance if it is not found.
  - The **Annotated Provider** handles key types that are instances of `typing.Annotated`. It works very similarly to the type provider except it allows you to provide an annotation. This is helpful if you have multiple instances of the same type that need to exist together. You could have `Annotated[Thing, "testA"]` and `Annotated[Thing, "testB"]`, both of them would be able to point to distinct instances of `Thing` in the same repository cache.

  It is possible to add new providers to the repository using it's `add_providers` method which takes any number of provider types.

  It is also possible to subclass `bevy.Repository`, provide a custom `factory` class method that returns an instance of `Repository` with whatever default providers you want set. Just call `Repository.set_repository` with an instance of the new repository type.


pkgId: bc2d8d53b208f9bde29516bb8b6e4a078edb19c4ed78a5097e0aafc553105b7d
name: python-Bext
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A cross-platform Python 2/3 module for colorful, boring, text-based terminal programs.
url: https://github.com/asweigart/bext
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bext-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A cross-platform Python 2/3 module for colorful, boring, text-based terminal programs.
  Basically, use Bext if you want to move the cursor around the terminal window and have colorful text, like some kind of limited curses module (but it works on Windows also.)
  Bext does not currently work in the new Windows Terminal. It does work in the older Command Prompt.
  Note: Currently something in Colorama 0.4.6 causes Bext to fail. Please use 0.4.5 or earlier.


pkgId: e387f564ce86a7875a296a82b8fe387af7cb08b6ae3106ca8dafd0c683bc5856
name: python-Bgolearn
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: A Bayesian global optimization package for material design
url: https://github.com/Bin-Cao/Bgolearn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bgolearn-2.3.1-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/badge/PyPI-caobin-blue)](https://pypi.org/project/Bgolearn/)




  ![Screen Shot 2022-07-11 at 9 13 28 AM](https://user-images.githubusercontent.com/86995074/178176016-8a79db81-fcfb-4af0-9b1c-aa4e6a113b5e.png)





  Reference paper : V. Picheny, T. Wagner, and D. Ginsbourger. “A Benchmark of Kriging-Based Infill Criteria for Noisy Optimization”. In: Structural and Multidisciplinary Optimization 48.3 (Sept. 2013), pp. 607–626. issn: 1615-1488.


  Written using Python, which is suitable for operating systems, e.g., Windows/Linux/MAC OS etc.


  Bgolearn guides subsequent material design based on existed experimental data. Which includes: 1.Expected Improvement algorithm, 2.Expected improvement with “plugin”，3.Augmented Expected Improvement，4.Expected Quantile Improvement，5.Reinterpolation Expected Improvement， 6.Upper confidence bound，7.Probability of Improvement，8.Predictive Entropy Search，9.Knowledge Gradient, a total of nine Utility Functions. Predictive Entropy Search，Knowledge Gradient are implemented based on Monte Carlo simulation.（贝叶斯优化设计，根据已有的实验数据对后续材料设计作出指导，本算法包共包括：期望最大化算法，期望最大化算法改进（考虑数据噪声），上确界方法，期望提升方法，熵搜索，知识梯度方法等在内的共计9种贝叶斯采样方法。其中熵搜索和知识梯度方法基于蒙特卡洛实现）


  pip install Bgolearn


  pip install --upgrade Bgolearn


  Maintained by Bin Cao. Please feel free to open issues in the Github or contact Bin Cao
  (bcao@shu.edu.cn) in case of any problems/comments/suggestions in using the code.


pkgId: f7f8629a1709007148ac50f42fe881c07187602107bc827fac82de48afcb6b78
name: python-BharatFinTrack
arch: src
version: 0.1.10
epoch: 0
release: 1
url: https://github.com/debpal/BharatFinTrack
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BharatFinTrack-0.1.10-1.src.rpm
checksum_type: sha256
summary:
  Downloading and analyzing financial data, including indices, stocks, bonds, and mutual funds, from India, that is Bharat.

description:
  | <big>Status</big> | <big>Description</big> |
  | --- | --- |
  | **PyPI**| ![PyPI - Version](https://img.shields.io/pypi/v/BharatFinTrack) ![PyPI - Status](https://img.shields.io/pypi/status/BharatFinTrack) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/BharatFinTrack) ![PyPI - Wheel](https://img.shields.io/pypi/wheel/BharatFinTrack) |
  | **GitHub** | ![GitHub last commit](https://img.shields.io/github/last-commit/debpal/BharatFinTrack) [![flake8](https://github.com/debpal/BharatFinTrack/actions/workflows/linting.yml/badge.svg)](https://github.com/debpal/BharatFinTrack/actions/workflows/linting.yml)	[![mypy](https://github.com/debpal/BharatFinTrack/actions/workflows/typing.yml/badge.svg)](https://github.com/debpal/BharatFinTrack/actions/workflows/typing.yml) [![pytest](https://github.com/debpal/BharatFinTrack/actions/workflows/testing.yml/badge.svg)](https://github.com/debpal/BharatFinTrack/actions/workflows/testing.yml) |
  | **Codecov** | [![codecov](https://codecov.io/github/debpal/BharatFinTrack/graph/badge.svg?token=6DIYX8MUTM)](https://codecov.io/github/debpal/BharatFinTrack) |
  | **Read** _the_ **Docs** | [![Documentation Status](https://readthedocs.org/projects/bharatfintrack/badge/?version=latest)](https://bharatfintrack.readthedocs.io/en/latest/?badge=latest) |
  | **PePy** | ![Pepy Total Downloads](https://img.shields.io/pepy/dt/BharatFinTrack)|
  | **License** | ![PyPI - License](https://img.shields.io/pypi/l/BharatFinTrack) |


  `BharatFinTrack` is a Python package designed to simplify the process of downloading and analyzing financial data from India. Conceptualized on September 1, 2024, and launched on September 8, 2024, this package is tailored for long-term investors seeking to streamline their financial data workflows.

  `BharatFinTrack` focuses on open-source financial data, with an initial emphasis on analyzing NSE equity indices. However, it is important to note that the package does not include features for technical indicators or real-time trading. Active development is ongoing, with exciting new features planned for future releases. The goal of BharatFinTrack is to empower users by providing easy access to open-source data, enabling them to make informed financial decisions. Currently, the package offers the following features:




  * Provides access to detailed information about NSE equity indices.
  * Enables downloading and updating daily (`TRI`) data for all NSE equity indices.
  * Fetches closing values for both `Price` (excluding dividend reinvestment) and `TRI` for all NSE equity indices.



  * Calculates CAGR for both `Price` and `TRI` since the inception of all NSE equity indices.
  * Compare CAGR (%) between `Price` and `TRI`.
  * Sorts NSE equity indices by CAGR (%) values.
  * Sorts NSE equity indices by CAGR (%) within each category.



  * Computes the year-wise SIP return for a fixed monthly contribution to a specified NSE equity `TRI` index.
  * Calculates the closing summary of an SIP with a fixed monthly contribution to a specified NSE equity `TRI` index, starting from a given date.
  * Compares the growth of a monthly SIP investment across multiple NSE equity `TRI` indices over the years.
  * Estimates annual SIP performance, including investment amount, closing balance, and cumulative growth over a specified number of years and expected annual return, with options for yearly, quarterly, monthly, or weekly contributions.




  * Displays bar graphs of NSE equity indices’ closing values with descending CAGR (%) since inception, both overall and by index category.
  * Shows bar graphs of top-performing NSE equity indices by CAGR (%) since launch, with options to view a specified number of top indices, either overall or within each category.
  * Depicts a bar graph of year-wise investments and returns for a monthly SIP of 1,000 Rupees in a specified NSE equity `TRI` index since its inception.
  * Provides a return comparison between a specified index and government bonds for a monthly SIP of 1,000 Rupees over the years.
  * Illustrates a line plot comparing the growth of a monthly SIP investment across multiple NSE equity `TRI` indices over the years.



  Using `BharatFinTrack`, you can quickly gain insights into the performance of NSE equity indices. For instance, the following bar plot highlights the top five NSE equity indices by `TRI` CAGR (%) within each category since their respective launches. This snapshot provides a powerful visual overview of long-term performance trends of investment multiples (X) across different index categories over the years. Because performance data updates daily with each trading session, you can replicate and customize this analysis to generate up-to-date insights tailored to your research needs or investment strategies.

  ![Category-wise Top Five TRI CAGR(%) of NSE Equity Indices](https://github.com/debpal/BharatFinTrack/raw/master/docs/_static/tri_top_cagr_by_category.png)

  In the above graph, the `NIFTY MIDCAP150 MOMENTUM 50` emerges as one of the best-performing NSE equity `TRI` indices in terms of long-term CAGR. The next graph illustrates a comparison of year-wise investments and returns for a monthly SIP of 1,000 Rupees between a government bond and a passive fund tracking the `TRI` data of `NIFTY MIDCAP150 MOMENTUM 50`.

  ![Year-wise SIP comparison between Government Bond and NIFTY_MIDCAP150_MOMENTUM_50](https://github.com/debpal/BharatFinTrack/raw/master/docs/_static/sip_gsec_vs_NIFTY_MIDCAP150_MOMENTUM_50.png)

  Additionally, the following plot compares the growth multiples (X) of a monthly SIP investment across `TRI` indices, including the popular index `NIFTY 50` and other top-performing NSE equity indices over the years.


  ![Year-wise SIP growth comparison across multiple indices](https://github.com/debpal/BharatFinTrack/raw/master/docs/_static/sip_growth_multiple.png)



  To install, use pip:

  ```bash
  pip install BharatFinTrack
  ```


  A brief example of how to start:

  ```python
  >>> import BharatFinTrack
  >>> nse_product = BharatFinTrack.NSEProduct()
  >>> nse_product.equity_index_category
  ['broad', 'sector', 'thematic', 'strategy', 'variant']


  >>> nse_product.all_equity_indices
  ['NIFTY 100',
   'NIFTY 200',
   'NIFTY 50',
   ...]
  ```


  For detailed information, see the [documentation](http://bharatfintrack.readthedocs.io/).



  If this project has been helpful and you'd like to contribute to its development, consider sponsoring with a coffee! Support will help maintain, improve, and expand this open-source project, ensuring continued valuable tools for the community.


  [![Buy Me a Coffee](https://img.shields.io/badge/☕_Buy_me_a_coffee-FFDD00?style=for-the-badge)](https://www.buymeacoffee.com/debasish_pal)


pkgId: 9e8ee4d333dcc45004e4ac5328c981e966c686c6b69256879eeac76aab08c662
name: python-BiasedErasure
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Simulate logical circuits with loss errors with efficient smart decoding
url: https://pypi.org/project/BiasedErasure/
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BiasedErasure-0.1.6-1.src.rpm
checksum_type: sha256
description:
  To install the package so that you can call it from the command line, run either "pip install -e ." (developer instillation) or "pip install ." (regular) from the erasure_biased_errors folder. The former option will reflect local changes that you make to the packages when you run it from the command line. The latter will always call the current version of the code without any local changes.

  Important! To use this package, you must you the "loss_decoder" branch in qec package.


pkgId: c9a341ed11451ef7f634fd4c58ea8dd63575d2f269b3ca344e134f8c8ade1c24
name: python-BibleHubScrapper
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: A module to scrape biblehub.com, also cli app
url: https://github.com/joshpetit/BibleHubScrapper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BibleHubScrapper-1.3.4-1.src.rpm
checksum_type: sha256
description:
  A python module that retrieve a single verse and the information on it from biblehub.com.
  Also a simple commandline application


  ```pip3 install BibleHubScrapper```


  To retrieve all the currently available information on a reference, use the '-a' tag:

  `biblehub -a [Reference]`

  To only retrieve specific information, pass in the corresponding tag:
  ```
  biblehub -c [Reference] # Also retrieves the cross-references
  biblehub -t [Reference] # Also retrieves the lexicon
  ```
  As with most cli tools, arguments can be stacked with one hyphen, such as:
  ```
  biblehub -cl [Reference] # Retrieves the cross-references and lexicon in addition to the passage
  ```

  You can import the query method to use in scripts.
  ```
  from BibleHubScrapper import query

  biblehub_query = query('Genesis 1:1')
  print(biblehub_query.text) # In the beginning...
  ```
  By default, it will query all possible fields.
  You can choose not to query certain fields by indicating in the parameters
  for example:
  ` query('Genesis 1:1', get_lexicons=False) `


  ```
  print(biblehub_query.passage) # Genesis 1:1
  print(biblehub_query.version) # NIV (default)
  print(biblehub_query.lexicons) # Text, Hebrew words, translit, strong, and English defintions
  print(biblehub_query.crfs) # Cross References
  print(biblehub_query.tos) # Treasury of Scripture
  print(biblehub_query.info) # Prints all the info queried on the verse. Also the same as the __str__
  ```
  there are also `biblehub_query.format_[field]` method that returns the specified field in an easy to read way.



  - Possibly support multiple verses
  - Possibly make vim plugin
  - Consider fetching commentaries, or a specific one
  - Implement search function
  - Reformat module structure
  - Create etc config file for formatting (colors, verbosity, etc.)


  If you feel like improving the codebase, adding a feature, or checking my grammar, feel free!
  Just make sure to send a pull request against the development branch.


pkgId: f47e632ab76245baf61e2deb3706c61a308146f38a13efa5063a9f2e7c368c45
name: python-Biblelator
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Biblelator — experimental USFM Bible Editor
url: http://Freely-Given.org/Software/Biblelator/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Biblelator-0.0.8-1.src.rpm
checksum_type: sha256
description:
  A USFM Bible editor using the [BibleOrgSys](https://pypi.org/project/BibleOrgSys/)
  library and Python's tKinter windowing library for simple and easy installation.
  (It's all in the standard CPython install.)

  On most systems, Biblelator can be installed (as shown above) with:

      `pip install Biblelator`

  but if it complains, maybe:

      `python3 -m pip install Biblelator`

  The app can be run from the command line with:

      `Biblelator`

  which should start up and display a smallish window,
  or to view all the available options:

      `Biblelator --help`

  You can discover the program version (doesn't match the package version) with:

      `Biblelator --version`

  Biblelator reads or creates a `BiblelatorData` folder in your home folder.
  Log files are stored in a subfolder there and may be useful for reporting errors.
  (If you have start-up problems, you might want to edit the settings there,
  or even delete the entire settings file if you have no complex saved windows settings yet.)

  Because some Bible users need to remain anonymous, Biblelator defaults to no internet use.
  However this reduces functionality, and most users will want to run the program once,
  and then close it and edit the `Biblelator.ini` file created in the `BiblelatorData/BiblelatorSettings` folder
  and change `internetAccess` to `Enabled`.
  While there, you might as well update the `currentUserName` and other entries
  under `[Users]`.

  The other auxilliary apps included are `BiblelatorSettingsEditor`,
  `BOSManager` (for inspecting Bible Organisational Systems), and
  `SwordManager` for viewing
  and downloading [Sword](https://crosswire.org/sword/index.jsp) modules.
  (All three are at various stages of incompleteness.)

  NOTE: This packaging is still being tested following massive restructuring,
  and is not necessarily fully functional until it is marked as v0.1.0 or higher
  when some open-licensed resources will also be downloadable.
  We also have hopes to improve documentation before v0.2.0.
  After that point, we also hope to release some prepackaged versions—
  probably including Docker and Snap.

  This software has been developed in very small chunks of spare time since 2013
  (so it's not necessarily well structured, and definitely not polished).
  However, it was used as my main Bible editor instead of Paratext
  for a couple of years.

  This package will not reach v1.0.0 until after the BibleOrgSys reaches it.
  The API will not become fixed/stable until the v1.0.0 release.

  No attempt at all has been made at memory or speed optimisations
  and this is not planned until after the release of v1.0.0.
  So if it becomes very slow, you might need to close some Bible resource windows.

  Biblelator is developed and tested on Linux (Ubuntu) but should also run on Windows and OS X (although not so well tested).

  See https://ubsicap.github.io/usfm/ for more information about USFM.


pkgId: ce5c311aa8fab55713d38ecccdea79b8dad3a8b255eb1abf646bac52591cf321
name: python-BiblioPixel
arch: src
version: 3.4.46
epoch: 0
release: 1
url: http://github.com/maniacallabs/bibliopixel/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BiblioPixel-3.4.46-1.src.rpm
checksum_type: sha256
summary:
  BiblioPixel is a pure python library for manipulating a wide variety of LED strip based displays, both in strip and matrix form.


pkgId: 2d09a653ce78cf2fe84cc90c29e8a6679e0a219ea0647d427d52cdb835022659
name: python-BiblioPixelAnimations
arch: src
version: 3.20190410.153508
epoch: 0
release: 1
url: http://github.com/maniacallabs/BiblioPixelAnimations/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BiblioPixelAnimations-3.20190410.153508-1.src.rpm
checksum_type: sha256
summary:
  BiblioPixelAnimations is an animation repository for animation classes that work with BiblioPixel: http://github.com/maniacallabs/BiblioPixel


pkgId: 4cd3fb40dd51bde9dff076021a637810eee867cc012ef265a96fb65fa05421de
name: python-Bidmanger-pkg
arch: src
version: 0.0.2
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-Bidmanger-pkg-0.0.2-1.src.rpm
checksum_type: sha256
description:
  The bidding_manager.py library is a key component of the application that manages all bidding-related functionalities for the property management system. It provides seamless integration with AWS DynamoDB to handle essential operations such as placing bids, retrieving all bids for a property, determining the highest bid, and accepting bids for properties.

  Key Features:

  	•	Placing Bids: Ensures buyers can place valid bids that are higher than the current highest bid for a property.
  	•	Fetching Bids: Retrieves all bids associated with a property and sorts them in descending order based on bid amount.
  	•	Determining the Highest Bid: Quickly identifies the highest bid placed on a property for validation and display purposes.
  	•	Accepting Bids: Allows sellers to accept a specific bid, marking the bid as “accepted” and updating the associated property’s status to “sold.”
  	•	Efficient Data Handling: Utilizes DynamoDB to store and query bid and property data efficiently, ensuring scalability and reliability.


pkgId: c47c3d801672a5dc6d8099df761bfed9603a1a7029c9d80e697e5a4dfae51e6b
name: python-BigEDA
arch: src
version: 0.0.58
epoch: 0
release: 1
summary: This is a package to carry out Exploratory Data Analysis, allowing to work with Big Data.
url: https://github.com/FabioScielzoOrtiz/EDA_Package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BigEDA-0.0.58-1.src.rpm
checksum_type: sha256
description:
  This is a package to carry out Exploratory Data Analysis, allowing to work on Big Data.

  We are currently working to develop the package.

  Usage:

  ```python
  pip install BigEDA --upgrade
  ```

  ```python
  import BigEDA
  from BigEDA import package_status
  ```

  ```python
  package_status()
  ```


pkgId: a3fc2fe61578ef72fe5f866f0c3c719483f9409c24621768e01b232b80d485ca
name: python-BigchainDB
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: BigchainDB: The Blockchain Database
url: https://github.com/BigchainDB/bigchaindb/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BigchainDB-2.2.2-1.src.rpm
checksum_type: sha256
description:
  BigchainDB allows developers and enterprises to deploy blockchain proof-of-concepts, platforms and applications with a blockchain database. BigchainDB supports a wide range of industries and use cases from identity and intellectual property to supply chains, energy, IoT and financial ecosystems. With high throughput, low latency, powerful query functionality, decentralized control, immutable data storage and built-in asset support, BigchainDB is like a database with blockchain characteristics.


pkgId: fb2357465bc03ef1b3349dff9a8987db15f0787447cb9c0396f095edd5b3bf06
name: python-Bigsansar
arch: src
version: 2.6.6
epoch: 0
release: 1
summary: Build one in minutes with bigsansar - a visual site building tool!
url: https://github.com/pokhrelb9/bigsansar
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bigsansar-2.6.6-1.src.rpm
checksum_type: sha256
description:
  * added tutorial about create unlimited users automatically.
  * fixed some bug in cloudflare api
  * Working in to cloudflare
  * fixed some bugs





  Bigsansar is available open-source under the [MIT](https://en.wikipedia.org/wiki/MIT_License) license. We recommend using the latest version of Python 3.
  Bigsansar is Fully based on django and linux ubuntu.  You can use [bigsansar](https://bigsansar.com) for install packaged.
  You can use
  [bigsansar](https://bigsansar.com)
  for install packaged.

  view our tutorials in
  [youtube](https://youtube.com/bigsansar)

  for playlist:
  [bigsansar for django](https://www.youtube.com/playlist?list=PLbGzLu1WXrFUXw7qr6AMz5_iEkEAPV_Vs)








  The latest and greatest Bigsasnar version is the one that’s in our Git repository (our revision-control system). This is only for experienced users who want to try incoming changes and help identify bugs before an official release. Get it using this shell command, which requires [Git](https://https://git-scm.com/):

  `git clone https://github.com/pokhrelb9/bigsansar.git`

  You can also download a [gzipped tarball](https://https://pypi.org/project/Bigsansar/#files) of the development version. This archive is updated every time we commit code.



  1) Type `bigsansar init` command for **automatically** setup server for internal configurations.

  ** this command valid into vertualenv for developer



  this is work only on ubuntu os

  2) type ` python manage.py setup_server` commend for fully setup into server .

  [How to Setup a Full Server with BigSansar, Django, and Ubuntu
  ](https://youtu.be/j8YN6x9XdR4)


  [sitemap.xml](http://localhost/sitemap.xml)
  [script.js](http://localhost/script.js)
  [styles.css](http://localhost/styles.css)



  create a page **slug** name with sitemap,script , styles



  go to **VirtualHost.py** file and change **localhost** with your subdomain


  `python manage.py createuser` - get unlimited users.

  [Get UNLIMITED Django Users Automatically with BigSansar
  ](https://youtu.be/UW0ytkPAMxw)



  {% extends '<domain_name>/<page_slug>.html' %}
  {% include '<domain_name>/<page_slug>.html' %}





  `{% load blogs %}
  {% get_blog as bloglist %}
            {% for list in bloglist %}
            <div class="card my-4">
                  <h5 class="card-header">{{list.title}} - {{ list.domain }}</h5>
              <div class="card-body">
                  <p class="card-text"> {{list.body|slice:":100"}} - {{ list.publish_date }}</p>
                  <a href="/blog/{{list.slug}}"
                     class="btn btn-danger">Read More</a>
              </div>
            </div>
            {% endfor %}`




  `{% load blogs %}
  {% get_blog_object as get_blog %}
  {{ get_blog.title }}
  {{ get_blog.thumbnails }}
  {{ get_blog.publish_date }}
  {{ get_blog.domain }}
  {{ get_blog.id }}
  {{ get_blog.slug }}
  {{ get_blog.body | safe }}
  {{ get_blog.visitor }}
  `


  `{% load blogs %}
  {% update_blog_visitor %}`


  {{ slug }}



  `{% load pages %}

  {% get_pages  as listpage %}
  {% for page in listpage %}
  <div>
      < a href="{{ page.slug }}">{{ page.title }}</a>
  </div>
  {% endfor %}`



  * page.id
  * page.domain
  * page.title
  * page.slug
  * page.body
  * page.visitor
  * page.publish_date



  * getpage.id
  * getpage.domain
  * getpage.title
  * getpage.slug
  * getpage.body
  * getpage.visitor
  * getpage.publish_date




  * gethost.id
  * gethost.user
  * gethost.domain
  * gethost.Description
  * gethost.publish_date
  * gethost.visitor




  **add this script in to html head **

  {% load static %}
  <script type="text/javascript" src="{% static 'ckeditor/ckeditor-init.js' %}"></script>
  <script type="text/javascript" src="{% static  'ckeditor/ckeditor/ckeditor.js' %}"></script>
  <link rel="stylesheet" href="{% static 'ckeditor/ckeditor/plugins/codesnippet/lib/highlight/styles/default.css' %}"/>
  <script src="{% static 'ckeditor/ckeditor/plugins/codesnippet/lib/highlight/highlight.pack.js' %}"></script>
  <script>hljs.initHighlightingOnLoad();</script>


pkgId: 544402f2fc5b10e53121f647d22a72f2f09419af9cddccdaccb40cf38bd1e045
name: python-BinField
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Python BinField implementation for binary data manipulation
url: https://github.com/penguinolog/binfield
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BinField-0.9.3-1.src.rpm
checksum_type: sha256
description:
  Python binfield implementation for binary data manipulation.
      Why? Python supports binary data manipulation via binary operations out of the box and it's fast,
      but it's hard to read and painful during prototyping, especially for complex (nested) structures.
      This library is designed to fix this issue: it allows to operate with binary data like dict with constant indexes:
      you just need to define structure class and create an instance with start data.
      Now you can use indexes for reading and writing data
  **Pros**:
  * Free software: Apache license
  * Open Source: https://github.com/penguinolog/binfield
  * Self-documented code: docstrings with types in comments
  * Tested: see badges on top
  * Support multiple Python versions:
      Python 2.7
      Python 3.4
      Python 3.5
      Python 3.6
      Python 3.7
      PyPy
      PyPy3
      Jyton 2.7


pkgId: 7092684c7c1976e566bfdd43fb8cadf8371e4eacbc8851e58a081e06738a585c
name: python-BindingGP
arch: src
version: 0.0.36
epoch: 0
release: 1
url: https://github.com/boliqq07/bgp
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BindingGP-0.0.36-1.src.rpm
checksum_type: sha256
summary:
  This is for symbolic regression.Some of code are non-originality, just copy for use. All the referenced code are marked,details can be shown in their sources

description:
  Welcome to BGP.
  BGP (Binding Genetic Programming) is an open python library that implements a comprehensive set of symbolic regression
  tools for materials informatics.
  This tool contains a symbol regression tool with dimension calculation, which is aimed at establish expressions with
  physical limitation.
  BGP inspired by:
  [XenonPy](https://github.com/yoshida-lab/XenonPy),
  [matminer](https://hackingmaterials.github.io/matminer/ ),
  [deap](https://github.com/DEAP/deap),
  [sympy](https://www.sympy.org/en/index.html)


pkgId: ccbea34032a8a458437e13c80f00a2df0cb66ed80c9f5fe471dd5aa39caaee4c
name: python-Binette
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Binette: accurate binning refinement tool to constructs high quality MAGs.
url: https://pypi.org/project/Binette/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Binette-1.0.4-1.src.rpm
checksum_type: sha256
description:
  [![install with bioconda](https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg?style=flat)](http://bioconda.github.io/recipes/binette/README.html)  [![Anaconda-Server Badge](https://anaconda.org/bioconda/binette/badges/downloads.svg)](https://anaconda.org/bioconda/binette)
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/binette/badges/license.svg)](https://anaconda.org/bioconda/binette)
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/binette/badges/version.svg)](https://anaconda.org/bioconda/binette)
  [![PyPI version](https://badge.fury.io/py/Binette.svg)](https://badge.fury.io/py/Binette)
  [![status](https://joss.theoj.org/papers/ad304709d59f1a51a31614393b09ba2b/status.svg)](https://joss.theoj.org/papers/ad304709d59f1a51a31614393b09ba2b)

  [![Test Coverage](https://genotoul-bioinfo.github.io/Binette/coverage-badge.svg)](https://genotoul-bioinfo.github.io/Binette/)
  [![CI Status](https://github.com/genotoul-bioinfo/Binette/actions/workflows/binette_ci.yml/badge.svg)](https://github.com/genotoul-bioinfo/Binette/actions/workflows)
  [![Documentation Status](https://readthedocs.org/projects/binette/badge/?version=latest)](https://binette.readthedocs.io/en/latest/?badge=latest)




  Binette is a fast and accurate binning refinement tool to constructs high quality MAGs from the output of multiple binning tools.

  From the input bin sets, Binette constructs new hybrid bins. A bin can be seen as a set of contigs. When at least two bins overlap, meaning they share at least one contig, Binette utilizes basic set operations to create new bins.
  - Intersection bin: This bin consists of the contigs that are shared by the overlapping bins.
  - Difference bin: This bin contains the contigs that are exclusively found in one bin and not present in the others.
  - Union bin: The union bin includes all the contigs contained within the overlapping bins

  It then uses CheckM2 to assess bins quality to finally select the best bins possible.

  Binette is inspired from the metaWRAP bin-refinement tool but it effectively solves all the problems from that very tool.
  - Enhanced Speed: Binette significantly improves the speed of the refinement process. It achieves this by launching the initial steps of CheckM2, such as Prodigal and Diamond runs, only once on all contigs. These intermediate results are then utilized to assess the quality of any given bin, eliminating redundant computations and accelerating the refinement process.
  - No Limit on Input Bin Sets: Unlike its predecessor, Binette is not constrained by the number of input bin sets. It can handle and process multiple bin sets simultaneously.
  <!-- - Bin selection have been improved. It selects the best bins in a more accurate and elegant manner.
  - It is easier to use. -->

  A comprehensive documentation of Binette is avalaible here: https://binette.readthedocs.io/





  Binette can be easilly installed with conda

  ```bash
  conda create -c bioconda -c defaults -c conda-forge -n binette binette
  conda activate binette
  ```

  Binette should be able to run :

  ```
  binette -h
  ```




  Clone this repository:
  ```
  git clone https://github.com/genotoul-bioinfo/Binette
  cd Binette
  ```

  Then create a Conda environment using the `binette.yaml` file:
  ```
  conda env create -n binette -f binette.yaml
  conda activate binette
  ```

  Finally install Binette with pip

  ```
  pip install .
  ```

  Binette should be able to run :

  ```
  binette -h
  ```




  Before using Binette, it is necessary to download the CheckM2 database:

  ```bash
  checkm2 database --download --path <checkm2/database/>
  ```

  Make sure to replace `<checkm2/database/>` with the desired path where you want to store the CheckM2 database.






  Binette supports two input formats for bin sets:

  1. **Contig2bin Tables:** You can provide bin sets using contig2bin tables, which establish the relationship between each contig and its corresponding bin. In this format, you need to specify the `--contig2bin_tables` argument.

  For example, consider the following two `contig2bin_tables`:

  - `bin_set1.tsv`:

      ```tsv
      contig_1   binA
      contig_8   binA
      contig_15  binB
      contig_9   binC
      ```

  - `bin_set2.tsv`:

      ```tsv
      contig_1   bin.0
      contig_8   bin.0
      contig_15  bin.1
      contig_9   bin.2
      contig_10  bin.0
      ```

      The `binette` command to process this input would be:

      ```bash
      binette --contig2bin_tables bin_set1.tsv bin_set2.tsv --contigs assembly.fasta
      ```

  2. **Bin Directories:** Alternatively, you can use bin directories, where each bin is represented by a separate FASTA file. For this format, you need to provide the `--bin_dirs` argument. Here's an example of two bin directories:

      ```
      bin_set1/
      ├── binA.fa: contains sequences of contig_1, contig_8
      ├── binB.fa: contains sequences of contig_15
      └── binC.fa: contains sequences of contig_9
      ```

      ```
      bin_set2/
      ├── binA.fa: contains sequences of contig_1, contig_8, contig_10
      ├── binB.fa: contains sequences of contig_15
      └── binC.fa: contains sequences of contig_9
      ```

      The `binette` command to process this input would be:

      ```bash
      binette --bin_dirs bin_set1 bin_set2 --contigs assembly.fasta
      ```

  In both formats, the `--contigs` argument should specify a FASTA file containing all the contigs found in the bins. Typically, this file would be the assembly FASTA file used to generate the bins. In these exemple the `assembly.fasta` file should contain at least the five contigs mentioned in the `contig2bin_tables` files or in the bin fasta files: `contig_1`, `contig_8`, `contig_15`, `contig_9`, and `contig_10`.



  Binette results are stored in the `results` directory. You can specify a different directory using the `--outdir` option.

  In this directory you will find:
  - **`final_bins_quality_reports.tsv`**: This is a TSV (tab-separated values) file containing quality information about the final selected bins.
  - **`final_bins/`**: This directory stores all the selected bins in fasta format.
  - **`input_bins_quality_reports/`**: A directory storing quality reports for the input bin sets, with files following the same structure as `final_bins_quality_reports.tsv`.
  - **`temporary_files/`**: This directory contains intermediate files. If you choose to use the `--resume` option, Binette will utilize files in this directory to prevent the recomputation of time-consuming steps.


  The `final_bins_quality_reports.tsv` file contains the following columns:
  | Column Name         | Description                                                                                                  |
  |---------------------|--------------------------------------------------------------------------------------------------------------|
  | **bin_id**          | This column displays the unique ID of the bin.                                                             |
  | **origin**          | Indicates the source or origin of the bin, specifying from which bin set it originates or the intermediate set operation that created it. |
  | **name**            | The name of the bin.                                                                                        |
  | **completeness**    | The completeness of the bin, determined by CheckM2.                                                         |
  | **contamination**   | The contamination of the bin, determined by CheckM2.                                                       |
  | **score**           | This column displays the computed score, which is calculated as: `completeness - contamination * weight`. You can customize the contamination weight using the `--contamination_weight` option. |
  | **size**            | Represents the size of the bin in nucleotides.                                                              |
  | **N50**             | Displays the N50 of the bin.                                                                                |
  | **contig_count**    | The number of contigs contained within the bin.                                                             |



  To report bugs, request new features, or seek help and support, please open an [issue](https://github.com/genotoul-bioinfo/Binette/issues).




  This program is released as an open source software under the terms of [MIT License](LICENSE).




  Binette is scientific software, with a [published paper](https://joss.theoj.org/papers/10.21105/joss.06782) in the [Journal of Open-Source Software](https://joss.theoj.org/).
  If you use Binette in academic research, please cite the following paper:

  > Mainguy et al., (2024). Binette: a fast and accurate bin refinement tool to construct high quality Metagenome Assembled Genomes.. Journal of Open Source Software, 9(102), 6782, https://doi.org/10.21105/joss.06782


pkgId: 3fb897e54c803f9a681efa09b201d0a7903950f07720c5d6f0b4fa50bd989bb1
name: python-BingImageCreator
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: High quality image generation by Microsoft. Reverse engineered API.
url: https://github.com/acheong08/BingImageCreator
rpm_license: GNU General Public License v2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BingImageCreator-0.5.0-1.src.rpm
checksum_type: sha256
description:
  High quality image generation by Microsoft. Reverse engineered API.

  `pip3 install --upgrade BingImageCreator`

  ```
   $ python3 -m BingImageCreator -h
  usage: BingImageCreator.py [-h] -U U --prompt PROMPT [--output-dir OUTPUT_DIR]

  options:
    -h, --help            show this help message and exit
    -U U                  Auth cookie from browser
    --prompt PROMPT       Prompt to generate images for
    --asyncio             Use async to sync png
    --output-dir OUTPUT_DIR
                          Output directory
  ```

  [Developer Documentation](https://github.com/acheong08/BingImageCreator/blob/main/DOCUMENTATION.md)




  - Go to https://bing.com/.
  - F12 to open console
  - In the JavaScript console, type `cookieStore.get("_U").then(result => console.log(result.value))` and press enter
  - Copy the output. This is used in `--U` or `auth_cookie`.


  - Go to https://bing.com/.
  - F12 to open developer tools
  - navigate to the storage tab
  - expand the cookies tab
  - click on the `https://bing.com` cookie
  - copy the value from the `_U`


pkgId: 20954a8cef7a1b0e1b87440d3becefb6e2919d35dab7be4ce6518ed97e026149
name: python-BingImageCreator-fork
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: High quality image generation by Microsoft. Reverse engineered API.
url: https://github.com/yihong0618/BingImageCreator
rpm_license: GNU General Public License v2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BingImageCreator-fork-0.8.2-1.src.rpm
checksum_type: sha256
description:
  High quality image generation by Microsoft. Reverse engineered API.
  Fork from https://github.com/acheong08/BingImageCreator

  `pip3 install .`

  ```
   $ python3 -m BingImageCreator -h
  usage: BingImageCreator.py [-h] -U U --prompt PROMPT [--output-dir OUTPUT_DIR]

  options:
    -h, --help            show this help message and exit
    -U U                  Auth cookie from browser
    --prompt PROMPT       Prompt to generate images for
    --asyncio             Use async to sync png
    --output-dir OUTPUT_DIR
                          Output directory
  ```

  [Developer Documentation](https://github.com/acheong08/BingImageCreator/blob/main/DOCUMENTATION.md)





  - Go to https://bing.com/.
  - F12 to open XHR call some api to get the `cookie`
  - call some api to copy the `cookie`and use this
  - Copy the output. This is used in `--U` or `auth_cookie`.


pkgId: 4bfda338a16d53f29ee895b8e5e05670ec7ba4a25950bee4652ae9ef85ae5832
name: python-Bio-Epidemiology-NER
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Recognize bio-medical entities from a text corpus
url: https://github.com/dreji18/biomedicalNER
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bio-Epidemiology-NER-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Bio-Epidemiology-NER is an Python library built on top of biomedical-ner-all model to recognize bio-medical entities from a corpus or a medical report

  | Feature  | Output  |
  |---|---|
  | Named Entity Recognition | Recognize 84 bio-medical entities |
  | PDF Input | Read Pdf and tabulate the entities|
  | PDF Annotation | Annotate Entities in a medical pdf report|




  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install Bio-Epidemiology-NER

  ```bash
  pip install Bio-Epidemiology-NER
  ```

  This package has dependency over Pytorch, please install the required configuration from this link https://pytorch.org/get-started/locally/




  ```python

  from Bio_Epidemiology_NER.bio_recognizer import ner_prediction


  doc = """
  	CASE: A 28-year-old previously healthy man presented with a 6-week history of palpitations.
        The symptoms occurred during rest, 2â€“3 times per week, lasted up to 30 minutes at a time
        and were associated with dyspnea. Except for a grade 2/6 holosystolic tricuspid regurgitation
        murmur (best heard at the left sternal border with inspiratory accentuation), physical
        examination yielded unremarkable findings.
        """


  ner_prediction(corpus=doc, compute='cpu') #pass compute='gpu' if using gpu

  ```


  ```python

  from Bio_Epidemiology_NER.bio_recognizer import pdf_annotate


  pdffile = 'Alhashash-2020-Emergency surgical management.pdf'


  pdf_annotate(pdffile,compute='cpu', output_format='pdf') #pass compute='gpu' if using gpu


  pdf_annotate(pdffile,compute='cpu', output_format='csv') #pass compute='gpu' if using gpu


  pdf_annotate(pdffile,compute='cpu', output_format='all') #pass compute='gpu' if using gpu



  ```



  This model is part of the Research topic "AI in Biomedical field" conducted by Deepak John Reji, Shaina Raza. If you use this work (code, model or dataset),

  Please cite us and star at: https://github.com/dreji18/biomedicalNER


  [MIT](https://choosealicense.com/licenses/mit/) License


pkgId: 488658febef577058ab991d1e8e69be8a445e83fde19d12c03b9872a68f1103b
name: python-BioCRNpyler
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A chemical reaction network compiler for generating large biological circuit models
url: https://github.com/buildacell/biocrnpyler/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BioCRNpyler-1.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/buildacell/biocrnpyler/actions/workflows/deploy.yml/badge.svg)](https://github.com/biocircuits/bioscrape/actions/workflows/deploy_bioscrape.yml)
  [![codecov](https://codecov.io/gh/BuildACell/BioCRNPyler/branch/master/graph/badge.svg)](https://codecov.io/gh/BuildACell/BioCRNPyler)
  [![PyPI version](https://badge.fury.io/py/biocrnpyler.svg)](https://badge.fury.io/py/biocrnpyler)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/BuildACell/BioCRNPyler/master?filepath=%2Fexamples%2F)

  BioCRNPyler (pronounced Bio-Compiler) is a Python package for the creation, manipulation,
  and study of the structure, dynamics, and functions
  of complex biochemical networks.

  - **Mailing list:** [SBTools Google Group](https://groups.google.com/g/sbtools/) Email: sbtools@googlegroups.com
  - **Source:** https://github.com/BuildACell/BioCRNPyler
  - **Paper:** - [BioCRNpyler: Compiling Chemical Reaction Networks from Biomolecular Parts in Diverse Contexts](https://www.biorxiv.org/content/10.1101/2020.08.02.233478v1)
  - **Bug reports:** https://github.com/BuildACell/BioCRNPyler/issues
  - **Slack** Join the #biocrnpyler channel on SBTools slack: Ask on the public SBTools Google group to be added or send a message to one of the maintainers.



  BioCRNpyler allows for CRNs to be built by hand, adding Species and Reactions manually.

  ```python
  from biocrnpyler import *




  A = Species("A")
  B = Species("B")
  C = Species("C")
  D = Species("D")


  k1 = 3.
  k2 = 1.4


  R1 = Reaction.from_massaction([A], [B, B], k_forward = k1)
  R2 = Reaction.from_massaction([B], [C, D], k_forward = k2)


  CRN = ChemicalReactionNetwork(species = [A, B, C, D], reactions = [R1, R2])
  print(CRN)
  ```



  BioCRNpyler also allows for higher level descriptions to be compiled into a CRN. In the below example, a piece of synthetic DNA with two promoters pointing in opposite directions is constructed from a list of DNAparts which are combined together in a DNA_construct and then simulated in a TxTlExtract context, which represents a cell-free bacterial lysate with machinery like Ribosomes and Polymerases modeled explicitly.

  ![Specification to CRN Illustration](static/SpecificationToCRN.png)

  ```python
  from biocrnpyler import *


  ptet = RegulatedPromoter("ptet",["tetr"],leak=True) #this is a promoter repressed by tetR and has a leak reaction
  pconst = Promoter("pconst") #constitutive promoter
  pcomb = CombinatorialPromoter("pcomb",["arac","laci"], leak=False, tx_capable_list = [["arac"], ["laci"]]) #the Combinations A and B or just A or just B be transcribed
  utr1 = RBS("UTR1") #regular RBS
  utr2 = RBS("UTR1") #regular RBS
  gfp = CDS("GFP","GFP") #a CDS has a name and a protein name. so this one is called GFP and the protein is also called GFP
  fusrfp = CDS("fusRFP","RFP",no_stop_codons=["forward"]) #you can say that a protein has no stop codon. This is a little different from a fusion protein, because in this case you are saying that the ribosome reads through two proteins but still produces two distinct proteins, rather than one fused protein. This can happen in the case of the ta peptide which causes a peptide bond not to be formed while making a protein.
  rfp = CDS("RFP","RFP") #regular RFP
  cfp = CDS("CFP","CFP") #cfp
  t16 = Terminator("t16") #a terminator stops transcription


  construct = DNA_construct([[ptet,"forward"],[utr1,"forward"],[gfp,"forward"],[t16,"forward"],[t16,"reverse"],[rfp,"reverse"],[utr1,"reverse"],[pconst,"reverse"]])


  parameters={"cooperativity":2,"kb":100, "ku":10, "ktx":.05, "ktl":.2, "kdeg":2,"kint":.05}


  myMixture = TxTlExtract(name = "txtl", parameters = parameters, components = [construct])


  myCRN = myMixture.compile_crn()


  ```


  More advanced examples can be found in the [example](https://github.com/BuildACell/BioCRNPyler/tree/master/examples) folder,
  here's the first file in the Tutorial series: [Building CRNs](https://github.com/BuildACell/BioCRNPyler/blob/master/examples/1.%20Building%20CRNs%20Directly.ipynb)




  Install the latest version of BioCRNPyler::

      $ pip install biocrnpyler

  Install with all optional dependencies::

      $ pip install biocrnpyler[all]

  (Note that on some operating systems you made need to use "\[all\]" to avoid shell errors.)

  Further details about the installation process can be found in the [BioCRNPyler wiki](https://github.com/BuildACell/BioCRNPyler/wiki#installation).



  Please report any bugs that you find [here](https://github.com/BuildACell/BioCRNPyler/issues).
  Or, even better, fork the repository on [GitHub](https://github.com/BuildACell/BioCRNPyler),
  and create a pull request (PR). We welcome all changes, big or small, and we
  will help you make the PR if you are new to `git` (just ask on the issue and/or
  see [contribution guidelines](https://github.com/BuildACell/BioCRNPyler/blob/master/docs/CONTRIBUTING.md)).



  BioCRNpyler versions:

  * 1.1.2 (latest stable release): To install run `pip install biocrnpyler`
  * 1.1.1 (previous stable release, compatible only with python <= 3.10): To install run `pip install biocrnpyler==1.1.1`
  * 0.9.0 (beta release): To install run `pip install biocrnpyler==0.9.0`
  * 0.2.1 (alpha release): To install run `pip install biocrnpyler==0.2.1`


  Released under the BSD 3-Clause License (see `LICENSE`)

  Copyright (c) 2024, Build-A-Cell. All rights reserved.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2018, Build-A-Cell 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 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: 24796876b4abe149287d6aa58b9fe5536aa72be80d7dca559b328b2009ecca4d
name: python-BioPII
arch: src
version: 0.2.4
epoch: 0
release: 1
url: https://github.com/OckermanSethGVSU/BioPII
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BioPII-0.2.4-1.src.rpm
checksum_type: sha256
summary:
  BioPII (Biology Parallel Integral Image) is a Python package for performing sliding window analysis (SWA) on biological images.

description:
  BioPII (Biology Parallel Integral Image) is a Python package for performing sliding window analysis (SWA) on biological images. This package makes use of the integral image technique to drastically speedup SWA, enabling SWA analysis of images that would have been too large for previous SWA implementations.

  To use the package include the following statement at the top of your file: `from BioPII import PII`

  To cite this package, cite our [IEEE CIBCB 2023 short paper](https://www.researchgate.net/publication/382174274_Accelerating_Biological_Spatial_Cluster_Analysis_with_the_Parallel_Integral_Image_Technique).

  This code and package is under the MIT License - copyright (c) Seth Ockerman

  The package name is prounounced bio-pie :)


  We tested our summing SWA to determine its performance relative to past methods. We created a C++ SWA (referred to as DP-Naive) script which used dynamic programming to reduce the number of additions needed to be performed. DP-Naive SWA was already 400x faster than a naive approach (a simple four for loop approach) on small images and is used as the baseline for comparison to our integral-image-based methods.

  |                   | 30k by 30k | 30k by 30k Speedup | 40k by 50k | 40k by 50k Speedup | 60k by 60k | 60k by 60k Speedup |
  |-------------------|------------|--------------------|------------|--------------------|------------|--------------------|
  | **DP-Naive**      | 211,381,433| N/A                | 491,374,150| N/A                | 943,858,845     | N/A                |
  | **Integral Image**            | 56,693     | 3728x              | 253,082    | 1942x               | 319,666    | 2953x               |
  | **Parallel Integral Image**           | 20,137     | 10,497x             | 46,532     | 10,559x             | 86,583    | 10,901x            |

  *Note: SWA runtime in milliseconds on different image sizes; speedups relative to DP-Naive Solution*




  - Efficient computation for various biological image analysis tasks.
  - Supports different types of SWA (Sliding Window Analysis) algorithms.
  - Flexible window size selection for analyzing different cellular features.
  - GPU acceleration option for faster computations.
  - Works with numpy arrays for easy integration into existing workflows.



  You can install BioPII using pip:

  ``` pip3 install BioPII ```


  Documentation can be found internally within our code and in the [documentation file](./documentation.md).



  The average-SWA-algorithm and std-deviation-SWA algorithm have not been as tested as extensively as the sum-SWA-algorithm. If you discover a bug, please reach out to [sockerman@cs.wisc.edu](mailto:sockerman@cs.wisc.edu).


pkgId: 42509158314dc717cf994c6c69d87fd8ed7637d84ac4f0d73e31008675a534df
name: python-BioSANS2020
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Symbolic and Numeric Software for Systems Biology
url: https://efajiculay.github.io/SysBioSoft/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BioSANS2020-0.3.2-1.src.rpm
checksum_type: sha256
description:
  **BioSANS** is a free software for systems biology which is currently being developed in Academia Sinica Institute of Chemistry. The goal of this development is to make systems biology available to non-domain experts in the easiest possible way. Currently, BioSANS supports model creation, ODE propagation in both deterministic and stochastic settings, and post simulation analysis. It can be used either via the GUI, the command line interface ,and as a python import for experts users. BioSANS passed majority of the SBML semnatic and stochastic test cases. It also support parameter estimation and provides an easy to prepare input which follows basic elementary equation in chemistry. In the input file, reaction, initial concentration, and rate constants are required but the propensity expression is optional. The algorithm in BioSANS can infer the propensity from the reactions provided. If the users need special or non mass action type propensity, it can be encoded in the topology file as well. Complicated conditional expression and concentration modification are also supported in the topology file.

  The following summarized the symbolic and numeric features currently supported;



  1. Species analytical expression - works for most linear differential equation and few non-linear ordinary differential equations
  2. LNA covariace matrix - works for most linear differential equation and few non-linear ODE
  3. Steady state concentration - generally works for most problems especially linear ODE
  4. Network localization - topology based sentitivity matrix



  1. Linear noise approximation
  2. Parameter estimation
  3. Network localization
  4. Deterministic analysis (ODE integration)
    * odeint - python LSODA library
    * runge-kutta4 (tau-adaptive and fixed interval version)
    * Euler (two differnt types of tau-adaptive version)
  5. Stochastic modeling
    * Chemical Langevine equation (tau-adaptive and fixed interval version)
    * Tau-leaping algorithm (2 different versions/implementation of Yang Cao's algorithm)
    * Gillespie direct method



  1. Plotting (trajectory, density, etc.)
  2. Calculation of correlation, covariance, fano-factor, etc.
  3. Phase portrait
  4. etc.


pkgId: 0dc30934229e4259adf649bd47182d500d9b14aed61734d7038586f789bd9de2
name: python-BioSequences
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Tools to analysis biology sequence
url: https://github.com/Dragon-GCS/BioSequence
rpm_license: GPL License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BioSequences-1.1.5-1.src.rpm
checksum_type: sha256
description:
  - [BioSequences](#biosequences)
    - [关于本项目](#关于本项目)
    - [安装](#安装)
      - [pip 安装](#pip-安装)
      - [下载源码安装](#下载源码安装)
    - [示例](#示例)
      - [加载序列信息](#加载序列信息)
      - [序列基本操作](#序列基本操作)
    - [贡献者](#贡献者)


pkgId: bb0b4c95df451acfe2753022c1015d9539819c86595a7a89aa367b583b8ed949
name: python-BiocFrame
arch: src
version: 0.5.11
epoch: 0
release: 1
summary: Flexible dataframe representation to support nested structures.
url: https://github.com/BiocPy/biocframe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BiocFrame-0.5.11-1.src.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Built Status](https://api.cirrus-ci.com/github/<USER>/BiocFrame.svg?branch=main)](https://cirrus-ci.com/github/<USER>/BiocFrame)
  [![ReadTheDocs](https://readthedocs.org/projects/BiocFrame/badge/?version=latest)](https://BiocFrame.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/BiocFrame/main.svg)](https://coveralls.io/r/<USER>/BiocFrame)
  [![PyPI-Server](https://img.shields.io/pypi/v/BiocFrame.svg)](https://pypi.org/project/BiocFrame/)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/BiocFrame.svg)](https://anaconda.org/conda-forge/BiocFrame)
  [![Monthly Downloads](https://pepy.tech/badge/BiocFrame/month)](https://pepy.tech/project/BiocFrame)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/BiocFrame)
  -->

  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)
  [![PyPI-Server](https://img.shields.io/pypi/v/BiocFrame.svg)](https://pypi.org/project/BiocFrame/)
  ![Unit tests](https://github.com/BiocPy/BiocFrame/actions/workflows/pypi-test.yml/badge.svg)





  This package implements the `BiocFrame` class, a Bioconductor-friendly alternative to Pandas `DataFrame`.
  The main advantage is that the `BiocFrame` makes no assumption on the types of the columns -
  as long as an object has a length (`__len__`) and slicing methods (`__getitem__`), it can be used inside a `BiocFrame`.
  This allows us to accept arbitrarily complex objects as columns, which is often the case in Bioconductor objects.

  To get started, install the package from [PyPI](https://pypi.org/project/biocframe/):

  ```shell
  pip install biocframe
  ```



  To construct a `BiocFrame` object, simply provide the data as a dictionary.

  ```python
  from biocframe import BiocFrame

  obj = {
      "ensembl": ["ENS00001", "ENS00002", "ENS00003"],
      "symbol": ["MAP1A", "BIN1", "ESR1"],
  }
  bframe = BiocFrame(obj)
  print(bframe)






  ```

  You can specify complex objects as columns, as long as they have some "length" equal to the number of rows.
  For example, we can nest a `BiocFrame` inside another `BiocFrame`:

  ```python
  obj = {
      "ensembl": ["ENS00001", "ENS00002", "ENS00002"],
      "symbol": ["MAP1A", "BIN1", "ESR1"],
      "ranges": BiocFrame({
          "chr": ["chr1", "chr2", "chr3"],
          "start": [1000, 1100, 5000],
          "end": [1100, 4000, 5500]
      }),
  }

  bframe2 = BiocFrame(obj, row_names=["row1", "row2", "row3"])
  print(bframe2)






  ```



  Properties can be accessed directly from the object:

  ```python
  print(bframe.shape)


  print(bframe.get_column_names())


  print(bframe.column_names) # same as above

  ```

  We can fetch individual columns:

  ```python
  bframe.get_column("ensembl")


  bframe["ensembl"]

  ```

  And we can get individual rows as a dictionary:

  ```python
  bframe.get_row(2)

  ```

  To extract a subset of the data in the `BiocFrame`, we use the subset (`[]`) operator.
  This accepts different subsetting arguments like a boolean vector, a `slice` object, a sequence of indices, or row/column names.

  ```python
  sliced = bframe[1:2, [True, False, False]]
  print(sliced)





  sliced = bframe[[0,2], ["symbol", "ensembl"]]
  print(sliced)







  bframe["ensembl"]

  ```





  To set `BiocFrame` properties, we encourage a functional style of programming that avoids mutating the object.
  This avoids inadvertent modification of `BiocFrame`s that are part of larger data structures.

  ```python
  modified = bframe.set_column_names(["column1", "column2"])
  print(modified)








  print(bframe.get_column_names())

  ```

  To add new columns, or replace existing columns:

  ```python
  modified = bframe.set_column("symbol", ["A", "B", "C"])
  print(modified)







  modified = bframe.set_column("new_col_name", range(2, 5))
  print(modified)






  ```

  Change the row or column names:

  ```python
  modified = bframe.\
      set_column_names(["FOO", "BAR"]).\
      set_row_names(['alpha', 'bravo', 'charlie'])
  print(modified)






  ```

  We also support Bioconductor's metadata concepts, either along the columns or for the entire object:

  ```python
  modified = bframe.\
      set_metadata({ "author": "Jayaram Kancherla" }).\
      set_column_data(BiocFrame({"column_source": ["Ensembl", "HGNC" ]}))
  print(modified)









  ```



  Properties can also be set by direct assignment for in-place modification.
  We prefer not to do it this way as it can silently mutate ``BiocFrame`` instances inside other data structures.
  Nonetheless:

  ```python
  testframe = BiocFrame({ "A": [1,2,3], "B": [4,5,6] })
  testframe.column_names = ["column1", "column2" ]
  print(testframe)






  ```

  Similarly, we could set or replace columns directly:

  ```python
  testframe["column2"] = ["A", "B", "C"]
  testframe[1:3, ["column1","column2"]] = BiocFrame({"x":[4, 5], "y":["E", "F"]})






  ```

  These assignments are the same as calling the corresponding `set_*()` methods with `in_place = True`.
  It is best to do this only if the `BiocFrame` object is not being used anywhere else;
  otherwise, it is safer to just create a (shallow) copy via the default `in_place = False`.



  **BiocFrame** implements methods for the various `combine` generics from [**BiocUtils**](https://github.com/BiocPy/biocutils).
  So, for example, to combine by row:

  ```python
  import biocutils

  bframe1 = BiocFrame(
      {
          "odd": [1, 3, 5, 7, 9],
          "even": [0, 2, 4, 6, 8],
      }
  )

  bframe2 = BiocFrame(
      {
          "odd": [11, 33, 55, 77, 99],
          "even": [0, 22, 44, 66, 88],
      }
  )

  combined = biocutils.combine_rows(bframe1, bframe2)
  print(combined)













  ```

  Similarly, to combine by column:

  ```python
  bframe3 = BiocFrame(
      {
          "foo": ["A", "B", "C", "D", "E"],
          "bar": [True, False, True, False, True]
      }
  )

  combined = biocutils.combine_columns(bframe1, bframe3)
  print(combined)
  BiocFrame with 5 rows and 4 columns
         odd   even    foo    bar
      <list> <list> <list> <list>
  [0]      1      0      A   True
  [1]      3      2      B  False
  [2]      5      4      C   True
  [3]      7      6      D  False
  [4]      9      8      E   True
  ```

  By default, both methods above assume that the number and identity of columns (for `combine_rows()`) or rows (for `combine_columns()`) are the same across objects.
  If this is not the case, e.g., with different columns across objects, we can use **BiocFrame**'s `relaxed_combine_rows()` instead:

  ```python
  from biocframe import relaxed_combine_rows
  modified2 = bframe2.set_column("foo", ["A", "B", "C", "D", "E"])
  combined = relaxed_combine_rows(bframe1, modified2)
  print(combined)













  ```

  Similarly, if the rows are different, we can use **BiocFrame**'s `merge` function:

  ```python
  from biocframe import merge
  modified1 = bframe1.set_row_names(["A", "B", "C", "D", "E"])
  modified3 = bframe3.set_row_names(["C", "D", "E", "F", "G"])
  combined = merge([modified1, modified3], by=None, join="outer")










  ```



  `BiocFrame` is intended for accurate representation of Bioconductor objects for interoperability with R.
  Most users will probably prefer to work with **pandas** `DataFrame` objects for their actual analyses.
  This conversion is easily achieved:

  ```python
  from biocframe import BiocFrame
  bframe = BiocFrame(
      {
          "foo": ["A", "B", "C", "D", "E"],
          "bar": [True, False, True, False, True]
      }
  )

  pd = bframe.to_pandas()
  print(pd)






  ```

  Conversion back to a ``BiocFrame`` is similarly easy:

  ```python
  out = BiocFrame.from_pandas(pd)
  print(out)








  ```



  Check out [the reference documentation](https://biocpy.github.io/BiocFrame/) for more details.

  Also see check out Bioconductor's [**S4Vectors**](https://bioconductor.org/packages/S4Vectors) package,
  which implements the `DFrame` class on which `BiocFrame` was based.


pkgId: 4cf6888c02b89ad9b280e4cd133708f4cb3383d7d9660b5821016b791d1133e7
name: python-BiocGenerics
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Generics for core data structures in biocpy
url: https://github.com/biocpy/generics
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BiocGenerics-0.1.3-1.src.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)
  [![Built Status](https://api.cirrus-ci.com/github/<USER>/biocgenerics.svg?branch=main)](https://cirrus-ci.com/github/<USER>/biocgenerics)
  [![ReadTheDocs](https://readthedocs.org/projects/biocgenerics/badge/?version=latest)](https://biocgenerics.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/biocgenerics/main.svg)](https://coveralls.io/r/<USER>/biocgenerics)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/biocgenerics.svg)](https://anaconda.org/conda-forge/biocgenerics)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/biocgenerics)
  -->



  [![PyPI-Server](https://img.shields.io/pypi/v/biocgenerics.svg)](https://pypi.org/project/biocgenerics/)
  [![Monthly Downloads](https://pepy.tech/badge/biocgenerics/month)](https://pepy.tech/project/biocgenerics)
  ![Unit tests](https://github.com/BiocPy/generics/actions/workflows/pypi-test.yml/badge.svg)

  This package aims to provide common generics, much like R/Bioconductor. These generics allow users to operate on different objects is a consistent and reliable way.



  Install package from [PyPI](https://pypi.org/project/biocgenerics/)

  ```shell
  pip install biocgenerics
  ```



  Combine provide multiple functions to concatenate sequences and array-like objects.

  - `combine_seqs`: Combine 1-dimensional sequences or vector-like objects.
  - `combine_rows`: Combine n-dimensional or DataFrame like objects along the first dimension.
  - `combine_cols`: Combine n-dimensional or DataFrame like objects along the second dimension.

  ```python
  from biocgenerics import combine_seqs, combine_rows


  x = [1, 2, 3]
  y = [0.1, 0.2]

  print(combine_seqs(x, y))




  num_cols = 20
  x = np.ones(shape=(10, num_cols))
  y = sp.identity(num_cols)

  print(combine_rows(x, y))
  ```

  Additionally, the `combine` generic, automatically dispatches to either `combine_seqs` or `combine_cols` methods depending on the inputs.



  Reliably access row and column names of **Dataframe**-like objects.

  - `rownames`: Access row names of the object.
  - `set_rownames`: Set new row names.
  - `colnames`: Access column names.
  - `set_colnames`: Set new column names.

  ```python
  import pandas as pd
  from biocgenerics import rownames

  df1 = pd.DataFrame([["a", 1], ["b", 2]], columns=["letter", "number"])

  rownames(df1)
  ```

  Check out the [S4Vectors](https://github.com/Bioconductor/S4Vectors) package for more information.

  <!-- pyscaffold-notes -->



  This project has been set up using PyScaffold 4.4. For details and usage
  information on PyScaffold see https://pyscaffold.org/.


pkgId: a1edaccdf8a1257262eed947de11f7c84397512cf9d82c944b53cbe3ffd85e78
name: python-Bioplots
arch: src
version: 0.1.6.9
epoch: 0
release: 1
summary: A data visualization package for bioinformatians and computational biologist
url: https://jingxinfu.github.io/Bioplots
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bioplots-0.1.6.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/Bioplots?color=blue)](https://pypi.org/project/Bioplots/) ![PyPI - Format](https://img.shields.io/pypi/format/Bioplots?style=flat-square) ![PyPI - License](https://img.shields.io/pypi/l/Bioplots?color=red) [![Build Status](https://travis-ci.org/jingxinfu/Bioplots.svg?branch=master)](https://travis-ci.org/jingxinfu/Bioplots) [![PyPI - Downloads](https://img.shields.io/pypi/dm/Bioplots?color=green&label=pypi%20download&logoColor=green&style=flat-square)](https://pypi.org/project/Bioplots/)

  This package provides visualization functions that are frequently used by bioinformaticians.

  [Document](https://jingxinfu.github.io/Bioplots)


pkgId: 92aae6f2641b2c6a350ab53a401dafd07e5cd3ec4930bced8780c151a6f97e2c
name: python-BitBridge
arch: src
version: 0.3.5
epoch: 0
release: 1
url: https://github.com/godd0t/bitbridge
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BitBridge-0.3.5-1.src.rpm
checksum_type: sha256
summary:
  A modern Python interface to the Bitcoin Core RPC, offering both synchronous and asynchronous support.

description:
  BitBridge offers a seamless Python interface to the Bitcoin Core RPC, simplifying interactions with the Bitcoin protocol. With support for both synchronous and asynchronous operations, BitBridge is perfectly suited for diverse applications - from web platforms and backend services to data analytics tools.



  - **Dual Mode Operations**: Supports both synchronous and asynchronous operations, giving you the flexibility to choose based on your application's needs.

  - **Modularity at Core**: Designed with a modular architecture, BitBridge can easily be extended and integrated into a variety of systems.

  - **Complete RPC Integration**: Comprehensive coverage of all RPC methods offered by Bitcoin Core, ensuring you have everything you need for Bitcoin interactions in one place.



  ```bash
  pip install BitBridge
  ```





  ```python
  from bitbridge import BitBridgeFacade, BitBridgeConfig


  config = BitBridgeConfig(url="http://127.0.0.1:8332", username="your_username", password="your_password")
  bridge = BitBridgeFacade(config)

  def fetch_best_block():
      
      best_block_hash = bridge.blockchain.get_best_block_hash()
      
  ```



  ```python
  from bitbridge import AsyncBitBridgeFacade, BitBridgeConfig


  config = BitBridgeConfig(url="http://127.0.0.1:8332", username="your_username", password="your_password")
  bridge = AsyncBitBridgeFacade(config)

  async def fetch_best_block():
      
      best_block_hash = await bridge.blockchain.get_best_block_hash()
      
  ```



  🚧 **Development Phase**: Please note that BitBridge is still in its initial development phase. Some features might be experimental.



  BitBridge is open-sourced under the [MIT License](https://github.com/godd0t/bitbridge/blob/main/LICENSE).


