# packages

pkgId: be3074ede785543f4dca834dd316e6c92c5f0e3c505b3fc738743805c82a6fb4
name: python-BitVector
arch: src
version: 3.5.0
epoch: 0
release: 1
summary: A memory-efficient packed representation for bit arrays in pure Python
url: https://engineering.purdue.edu/kak/dist/BitVector-3.5.0.html
rpm_license: Python Software Foundation License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BitVector-3.5.0-1.src.rpm
checksum_type: sha256
description:
  Consult the module API page at

      https://engineering.purdue.edu/kak/dist/BitVector-3.5.0.html

  for all information related to this module, including
  information regarding the latest changes to the code. The
  page at the URL shown above lists all of the module
  functionality you can invoke in your own code.

  With regard to the basic purpose of the module, it defines
  the BitVector class as a memory-efficient packed
  representation for bit arrays. The class comes with a large
  number of methods for using the representation in diverse
  applications such as computer security, computer vision,
  etc.

  **Version 3.5.0** makes the module compatible with Python 3.9 and
  also reverts __add__ to its implementation in 3.4.8 to get around
  a bug.

  **Version 3.4.9** includes significantly faster implementations
  for concatenating and extending bitvectors.

  The class is provided with the following operators/methods:

  -      __add__
  -      __and__
  -      __contains__
  -      __eq__, __ne__, __lt__, __le__, __gt__, __ge__
  -      __getitem__
  -      __iadd__
  -      __int__
  -      __invert__
  -      __iter__
  -      __len__
  -      __lshift__
  -      __or__
  -      __rshift__
  -      __setitem__
  -      __str__
  -      __xor__
  -      close_file_object
  -      count_bits
  -      count_bits_sparse      (faster for sparse bit vectors)
  -      deep_copy
  -      divide_into_two
  -      gcd                    (for greatest common divisor)
  -      gen_random_bits
  -      get_bitvector_in_ascii
  -      get_bitvector_in_hex
  -      gf_divide_by_modulus   (for modular divisions in GF(2^n))
  -      gf_MI                  (for multiplicative inverse in GF(2^n))
  -      gf_multiply            (for multiplications in GF(2))
  -      gf_multiply_modular    (for multiplications in GF(2^n))
  -      hamming_distance
  -      int_val                (for returning the integer value)
  -      is_power_of_2
  -      is_power_of_2_sparse   (faster for sparse bit vectors)
  -      jaccard_distance
  -      jaccard_similarity
  -      length
  -      min_canonical
  -      multiplicative_inverse
  -      next_set_bit
  -      pad_from_left
  -      pad_from_right
  -      permute
  -      rank_of_bit_set_at_index
  -      read_bits_from_file
  -      reset
  -      reverse
  -      runs
  -      set_value
  -      shift_left             (for non-circular left shift)
  -      shift_right            (for non-circular right shift)
  -      test_for_primality
  -      unpermute
  -      write_to_file
  -      write_bits_to_stream_object


pkgId: fba1891874bcfe3251ef0409d44bf8aae2bd6ec2821833a3fbfe125008bd055d
name: python-BitbucketJenkins
arch: src
version: 0.5.0
epoch: 0
release: 1
url: https://github.com/ericsonrumuy7/BitbucketJenkins
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BitbucketJenkins-0.5.0-1.src.rpm
checksum_type: sha256
summary:
  A package for create Bitbucket project that integrate with Jenkins using Bitbucket team/project plugin

description:
  A package for create Bitbucket project that integrate with Jenkins using Bitbucket team/project plugin


pkgId: 117f1fdc06a4607aab684f71328c90b4e4e4260de06b08ccd0d834323bdbd299
name: python-BlackBlazeFw
arch: src
version: 0.1.2.5
epoch: 0
release: 1
summary: A Minimalistic Web Framework
url: https://github.com/Black-Blaze/web-fw/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlackBlazeFw-0.1.2.5-1.src.rpm
checksum_type: sha256
description:
  Black Blaze-WEBfw is a minimalistic web framework for python. Documentation Available At
  [Github](https://github.com/Black-Blaze/web-fw/)


pkgId: db184005f53bf1160d9b863f2e2a88d17005c15f6f6a81b81d7ea581205af172
name: python-BlazeUtils
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A collection of python utility functions and classes.
url: https://github.com/blazelibs/blazeutils/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlazeUtils-0.7.0-1.src.rpm
checksum_type: sha256
description:
  BlazeUtils was originally developed as a library to hold common tools for the
  `Blaze library family <https://github.com/blazelibs/>`_.
  Over the years it has been expanded to be somewhat of a catch-all for tools commonly used by
  the `Level 12 <https://level12.io/>`_ development team.


pkgId: f59297ba6dc5eb27cdccb6b7771e2395f94f3627107d80ff8796a3fc32c4f751
name: python-BlinkStick
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python package to control BlinkStick USB devices.
url: http://pypi.python.org/pypi/BlinkStick/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlinkStick-1.2.0-1.src.rpm
checksum_type: sha256
description:
  - `Code repository on GitHub <https://github.com/arvydas/blinkstick-python>`_
  - `API reference documentation <https://arvydas.github.io/blinkstick-python>`_
  - `Code Examples <https://github.com/arvydas/blinkstick-python/wiki>`_


pkgId: 889a5177a6c65d5bd9e18ef05f82efe54a2dda9c133e17a7074ac714c3f4027c
name: python-BlizzardWarcraftAPI
arch: src
version: 0.2.7.2
epoch: 0
release: 1
summary: Warcraft API
url: https://github.com/Angeloffy/BlizzardWarcraftAPI/tree/main
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlizzardWarcraftAPI-0.2.7.2-1.src.rpm
checksum_type: sha256
description:
  ![image](https://drive.google.com/uc?export=view&id=1bwLWgLTIHPy23sTfufMNV9NHhvQ4vQ1y)

  BlizzardWarcraftAPI is a Python library designed to interact with the official World of Warcraft API provided by <a href="https://develop.battle.net/documentation/world-of-warcraft">Blizzard</a>. Although it is still a work in progress, active development is underway. It's important to note that this library is not an official Blizzard product, but rather the result of an independent developer's efforts.

  BlizzardWarcraftAPI aims to provide a convenient and user-friendly interface for developers to access and utilize the wealth of data available through the World of Warcraft API. With this library, you can retrieve information about characters, items, quests, guilds, and more. It abstracts away the complexities of making API requests and handling responses, allowing developers to focus on building their applications or tools.

  By leveraging Blizzard's official API, BlizzardWarcraftAPI ensures that the data obtained is accurate and up-to-date. As the library continues to evolve, additional features and enhancements will be added to expand its capabilities and improve its usability. Developers interested in utilizing the vast resources offered by the World of Warcraft API will find BlizzardWarcraftAPI to be a valuable tool in their projects.


  Install and update using <a href="https://pip.pypa.io/en/stable/getting-started/">pip</a>:
  ```shell
  pip install BlizzardWarcraftAPI
  ```





  ````python
  from BlizzardWarcraftAPI import BlizzardAuthToken

  token = BlizzardAuthToken("ClientID", "ClientSecret")
  token.get()
  ````



  ````python
  from BlizzardWarcraftAPI import BlizzardWarcraftAPI

  api = BlizzardWarcraftAPI("token", "region", "locale")

  GameData = api.GameData()
  Profile = api.Profile()

  GameData.get_AchievementCategory(1)
  Profile.get_CharacterHunterPetsSummary("ravencrest", "bicmex")
  ````


pkgId: c0ee7c7bbb50bba846e4ae42ee7e94e4c2e9e212f7158cbfae7cf07cb3f17cf1
name: python-BlockDAG
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: BlockDAGs for structured signature generation.
url: https://github.com/pritchardn/BlockDAG
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlockDAG-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-informational.svg)](https://opensource.org/licenses/MIT)
  ![Pylint: 10](https://github.com/pritchardn/BlockDAG/actions/workflows/pylint.yml/badge.svg)
  ![Tests: Passing](https://github.com/pritchardn/BlockDAG/actions/workflows/python-package.yml/badge.svg)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.6999445.svg)](https://doi.org/10.5281/zenodo.6999445)



  BlockDAGs for structured signature generation.

  A [Merkle-Tree](https://en.wikipedia.org/wiki/Merkle_tree) is a binary tree of hash nodes.
  This module implements an extension of this data-structure which differs in that:
  - Data can be included at any node in the structure
  - The structure between nodes can form a directed acyclic graph

  Note, this is, in principle, a superset of a MerkleTree.

  One creates a BlockDAG by providing a dictionary of vertices (id : dict())
  and list of edges (id: id tuples).

  For example (available in `examples/EX0.py`). Consider the following Graph:

  <img src="https://github.com/pritchardn/BlockDAG/blob/main/img/ActualDAG.JPG"  />

  Once processed, the following HashDAG is generated.

  <img src="https://github.com/pritchardn/BlockDAG/blob/main/img/HashDAG.JPG"  />

  Changing the values of a single vertex, or edges the graph signature will be completely different.
  Moreover, the hashes of all descendent vertices will be completely different too.

  The main method `build_block_dag` requires:
  - A dictionary of vertices, each with a unqiue key, and dictionary of fields as values
  - A list of tuples, describing the edges in the graph.
  - A hash function (returns the hex-digest of the provided data. `Hashlib` provides many)
  - A list of keys used to inclusively filter the data contained in each vertex. The values selected
  are placed in a MerkleTree, the root of which is used as the `datahash` for that vertex
  - A boolean, `append_hashes` which if True, will add the `hash` and graph `signature` to the
  original vertex dictionary.

  `bulid_block_dag` returns a dictionary with the `datahash`, `parenthashes` and `blockhash` for each vertex
  in the original graph, along with a whole-graph signature.

  The whole-graph `signature` is computed by collecting the hashes of all leaf nodes (no outgoing edges)
  then inserting them into a MerkleTree, and taking the root.



  Install it:

  `pip install blockdag`

  or clone it.

  There are several examples in `examples` to get started.
  You can compare blockdags to find differing vertices (by signature, not label) and print dags
  nicely.



  - Vertex keys are assumed to be unique
  - The fields 'hash' and 'signature' will be overwritten if `append_hashes` is set to `True`
  - While it will not cause any issues, cycles will be ignored in the original graph.


  Feel free to help out, submit issues and make merge requests.


pkgId: ca89be16bb537cd54257bcef26aad434e958cbf4a39e031c8a22cbd66e3a2881
name: python-BlockSDK
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: BlockSDK is an API service for blockchain applications
url: https://blocksdk.com
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlockSDK-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![@BLOCKSDK on Twitter](https://img.shields.io/badge/twitter-%40BLOCKSDK-blue.svg)](https://twitter.com/BlockSdk1)
  [![@BLOCKSDK on Facebook](https://img.shields.io/badge/facebook-%40BLOCKSDK-blue.svg)](https://www.facebook.com/blocksdk)
  [![PYTHON version](https://img.shields.io/pypi/v/BlockSDK.svg)](https://pypi.python.org/pypi/BlockSDK)
  [![PYPI downloads](https://img.shields.io/pypi/pyversions/BlockSDK.svg)](https://pypi.python.org/pypi/BlockSDK)

  BlockSDK PYTHON에 오신 것을 환영합니다. 이 저장소에는 BlockSDK의 PYTHON SDK와 REST API용 샘플이 포함되어 있습니다.


  비트코인 , 라이트코인 , 비트코인 캐시 , 웹후크 는 V2버전 에서 지원되고 있습니다.
  ```
  1.이더리움
  2.클레이튼
  3.바이낸스 스마트 체인
  4.폴리곤
  5.아발란체
  6.이더리움 클래식
  ```

  * [BlockSDK REST API V3 문서](https://documenter.getpostman.com/view/20292093/Uz5FKwxw)
  * [BlockSDK REST API V2 문서](https://docs-v2.blocksdk.com/ko/#fa255f0ccc)
  * [BLOCKSDK PYTHON SDK V3 문서](https://github.com/Block-Chen/blocksdk-python/wiki)



     - [deasync](https://www.npmjs.com/package/deasync) & [request](https://www.npmjs.com/package/request) extensions must be enabled


  SDK 설치 – pip를 사용하여 설치 것이 BLOCKSDK PYTHON SDK를 설치하는 권장 방법입니다.

  ```sh
  pip install BlockSDK
  ```



  ```python
  from BlockSDK.blocksdk import BlockSDK
  client = BlockSDK(api_token="YOU_TOKEN")
  ```

  엔드 포인트를 지정해주지 않는경우 테스트넷으로 기본 설정되어 호출 됩니다
  메인넷은 아래 예시와 같이 클라이언트 생성시 두번째 매개변수를 메인넷으로 지정해 주시길 바랍니다.
  ```python
  from BlockSDK.blocksdk import BlockSDK
  client = BlockSDK(api_token="YOU_TOKEN",endpoint="https://mainnet-api.blocksdk.com")
  ```

  ```python
  result = client.ethereum.GetBlockChainInfo();
  print(result);
  ```


  ```python
  nfts = client.ethereum.GetSingleNfts({
      "contract_address": "0xf5de760f2e916647fd766b4ad9e85ff943ce3a2b",
      "includeMetadata": False,
      "offset": 0,
      "limit": 10
  })

  print(nfts)
  ```


pkgId: 1b0610f9ffc0f29b79a6e91b58f7695e58448451209f50c18c0fe06bb26c2323
name: python-Blockthon
arch: src
version: 7.9.3
epoch: 0
release: 1
url: https://github.com/Blockthon/Blockthon
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Blockthon-7.9.3-1.src.rpm
checksum_type: sha256
summary:
  Blockthon: Fast and easy generation of Private Keys and Mnemonics, converting Seed, Binary, and Decimal.


pkgId: ca062e8627af80ee5f7e362dcc569b2a47a1195f32c7d0883d8e1b9770fa48e8
name: python-BlogX
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: a simple and pure blog generator based on html + css + python
url: https://github.com/faithleysath/BlogX
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlogX-0.3.0-1.src.rpm
checksum_type: sha256
description:
  > 极简之美：专注本质的静态博客生成器

  ![PyPI - Downloads](https://img.shields.io/pypi/dm/blogx)



  欢迎来到 BlogX，一个以极简主义理念打造的静态博客生成器，它将简单性和功能性完美结合。BlogX 以“专注做好一件事”为核心哲学，专注于将 Markdown 文件转换为 HTML，让您的博客体验变得轻松而高效。对于重视简洁、直接博客体验的开发者来说，它是完美的工具。



  具体来说，BlogX 在构建的过程中做了以下几个步骤：
  1. 拷贝静态资源文件到输出目录
  2. 复制src目录结构到输出目录
  3. 将Markdown文件转换为HTML文件



  BlogX 的特点如下：
  - **极简 CSS 和 JS**：BlogX 主题设计时尽可能减少 CSS 和 JavaScript 的使用，确保即使在禁用 JavaScript 的情况下，您的博客也能保持良好的显示效果（甚至包括$\LaTeX$公式）。
  - **低学习曲线**：BlogX 直观易用，易于理解，无论是新手还是经验丰富的开发者都能快速上手。
  - **单一职责**：BlogX 专注于一个任务：将 Markdown 文件转换为 HTML 并管理静态文件，让您自由组织网站结构。

  BlogX 不会做以下几件事：
  - **Tag标签与Category分类**：BlogX 不提供 Tag 标签和 Category 分类功能。当然，您可以自行手动维护这些信息。
  - **Index首页**：BlogX 不会自动生成首页，这意味着您需要自行编写`index.md`文件，以展示您的博客列表。
  - **评论系统**：BlogX 不会集成评论系统，您可以使用第三方评论系统，如 Disqus。

  除此以外，您可以自由定制您的博客目录结构，BlogX 不会强制您使用特定的目录结构。



  1. 安装 BlogX

  ```bash
  pip install blogx
  ```

  2. 初始化博客

  ```bash
  blogx init
  ```

  3. 查看目录结构

  ```
  C:.
  ├─src
  │  │  index.md
  │  │
  │  ├─haha
  │  │  │  index.md
  │  │  │
  │  │  └─nok
  │  │          dule.md
  │  │
  │  ├─some-article
  │  │      hello.md
  │  │
  │  ├─static
  │  │  └─img
  │  │          1.bmp
  │  │
  │  └─_global
  │          BLOGNAME
  │          footer.md
  │          header.md
  │          sidebar.md
  │
  └─theme
      │  template.html
      │
      └─static
          ├─css
          └─js
  ```

  其中`src`目录存放博客源文件，`theme`目录存放主题文件。`_global`目录存放全局文件，该目录不会被转换为HTML文件并复制到输出目录。

  | 文件名 | 作用 |
  | --- | --- |
  | BLOGNAME | 博客名称 |
  | footer.md | 页脚 |
  | header.md | 页眉 |
  | sidebar.md | 侧边栏 |

  4. 构建博客

  ```bash
  blogx build
  ```

  5. 查看输出目录

  ```
  C:.
  │  index.html
  │  template.html
  │
  ├─haha
  │  │  index.html
  │  │
  │  └─nok
  │          dule.html
  │
  ├─some-article
  │      hello.html
  │
  └─static
      ├─css
      ├─img
      │      1.bmp
      └─js
  ```

  6. 实时预览博客

  ```bash
  blogx serve
  ```

  该命令会在本地启动一个HTTP服务器，并实时监测文件变化，自动刷新页面。

  7. 部署博客

  ```bash
  blogx deploy
  ```

  请确保该目录是一个Github Pages仓库，BlogX会自动生成action文件并推送到Github仓库。


  我们欢迎对 BlogX 的贡献。无论您是想要添加新功能的开发者，还是发现漏洞的用户，您的贡献都是宝贵的。在提交拉取请求之前，请阅读我们的贡献指南。


  BlogX 是开源的，并在 MIT 许可证 下可用。您可以自由使用、修改和分发 BlogX。


  ![BlogX](example.png)


pkgId: b059e2b327d744dc9d56b7a4cab97c60ae018d0565f34fa859c58cfcb10a475f
name: python-BlueDesc-pywrapper
arch: src
version: 0.0.5.post1
epoch: 0
release: 1
summary: Python wrapper for BlueDesc molecular descriptors
url: https://github.com/OlivierBeq/bluedesc_pywrapper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlueDesc-pywrapper-0.0.5.post1-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)





  From source:

      git clone https://github.com/OlivierBeq/bluedesc_pywrapper.git
      pip install ./bluedesc_pywrapper

  with pip:

  ```bash
  pip install BlueDesc-pywrapper
  ```



  ```python
  from BlueDesc_pywrapper import BlueDesc
  from rdkit import Chem
  from rdkit.Chem import AllChem

  smiles_list = [
    
    "n1cnc(c2cc(c(cc12)OCCOC)OCCOC)Nc1cc(ccc1)C#C",
    
    "CCC(=O)O[C@@H]1CC(=O)O[C@@H](C/C=C/C=C/[C@@H]([C@@H](C[C@@H]([C@@H]([C@H]1OC)O[C@H]2[C@@H]([C@H]([C@@H]([C@H](O2)C)O[C@H]3C[C@@]([C@H]([C@@H](O3)C)OC(=O)CC)(C)O)N(C)C)O)CC=O)C)O)C",
    
    "C1=CC(=CC=C1C(=O)NC(CCC(=O)OCC[Se]C#N)C(=O)O)NCC2=CN=C3C(=N2)C(=O)NC(=N3)N",
  ]
  mols = [Chem.AddHs(Chem.MolFromSmiles(smiles)) for smiles in smiles_list]
  for mol in mols:
      _ = AllChem.EmbedMolecule(mol)

  bluedesc = BlueDesc()
  print(bluedesc.calculate(mols))
  ```

  The above calculates 118 molecular descriptors (33 1D and 85 2D).<br/>
  :warning: BlueDesc skips molecules it cannot parse internally, a warning is given when that is the case.
  The following command is recommended, should this occur, to prevent the unalignment of input and output indices.

  ```python
  bluedesc.calculate(mols, chunksize=1, njobs=-1)
  ```

  The additional 56 three-dimensional (3D) descriptors may be computed like so:
  :warning: Molecules are required to have conformers for 3D descriptors to be calculated.<br/>

  ```python
  bluedesc = BlueDesc(ignore_3D=False)
  print(bluedesc.calculate(mols))

  ```



  ```python
  def calculate(mols, show_banner=True, njobs=1, chunksize=1000):
  ```

  Default method to calculate BlueDesc descriptors.

  Parameters:

  - ***mols  : Iterable[Chem.Mol]***
    RDKit molecule objects for which to obtain BlueDesc descriptors.
  - ***show_banner  : bool***
    Displays default notice about BlueDesc.
  - ***njobs  : int***
    Maximum number of simultaneous processes.
  - ***chunksize  : int***
    Maximum number of molecules each process is charged of.


pkgId: 90ae6433420ba44cac2a0b13393052c6adc936bc57bd76530b1a674c0826f28a
name: python-BlueLights
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A library for controlling MohuanLED lights via Bluetooth
url: https://pypi.org/project/BlueLights/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlueLights-0.3.1-1.src.rpm
checksum_type: sha256
description:
  BJ_LED_M is a Python library designed to control MohuanLED brand lights via Bluetooth, directly from your laptop or PC (you’ll need a Bluetooth adapter if it’s not built-in). This library allows you to perform simple actions like turning the lights on/off, changing colors, and applying animations or reactions to external events. It also includes a PyQt6-based GUI for more intuitive control over the lights. 🌟


  The library is fully asynchronous, so you'll need to use asyncio and await. Here's an example of how to establish a direct connection, knowing the UUID and MAC address of the LEDs:

  ```python
  from bluelights import BJLEDInstance
  import asyncio

  ADDRESS = '64:11:a8:00:8b:a6'                      # Example address
  UUID = '0000ee02-0000-1000-2000-00805f9b34fb'      # Example UUID

  async def main():
      led = BJLEDInstance(address=ADDRESS, uuid=UUID)

      try:
        await led.turn_on()
        await led.set_color_to_rgb(255, 0, 0)          # Change color to red (RGB)

        await asyncio.sleep(5)                         # Wait 5 seconds
        await led.turn_off()                           # Turn off LEDs and disconnect
      except Exception as e:
        print(e)

      finally:
        await led._disconnect()                        # Clear the buffer

  asyncio.run(main())
  ```

  A dynamic example with the same orders:
  ```python
  from bluelights import BJLEDInstance
  import asyncio

  async def main():
      led = BJLEDInstance()                          # The Scanner will look for 'BJ_LED_M' (name of the devices) and connect
      try:
        await led.turn_on()
        await led.set_color_to_rgb(255, 0, 0)          # Change color to red (RGB)

        await asyncio.sleep(5)                         # Wait 5 seconds
        await led.turn_off()                           # Turn off LEDs and disconnect
      except Exception as e:
        print(e)

      finally:
        await led._disconnect()                        # Clear the buffer

  asyncio.run(main())
  ```


  - Control MohuanLED lights via Bluetooth (BLE)
  - Turn the LEDs on and off 💡
  - Change colors across the full RGB spectrum 🎨
  - Apply effects like:
    - 🔄 Color fade
    - 💡 Color strobe
    - 🌬️ Breathing effect between colors
    - 🌈 Rainbow cycle
    - 🌊 Wave effect
  - Graphical user interface (GUI) using PyQt6 (In development 🛠️)
  - Command Line Interface (CLI) for basic commands (In development 🛠️)
  - Dynamic MohuanLED device scanner for easy connections (In development 🛠️)
  - Automatic detection of UUIDs and MAC addresses




  - Python 3.8 or higher
  - PyQt6 and qasync
  - Built-in or external Bluetooth adapter
  - MohuanLED lights

  You can install the library via pip:

  ```bash
  pip install BlueLights
  ```

  Or install it directly from the repository:

  ```bash
  git clone https://github.com/Walkercito/MohuanLED-Bluetooth_LED
  cd BlueLights
  pip install .
  ```


  You can add various effects to the lights, such as rainbow_cycle, wave_effect, or strobe_light. Here are a few examples:

  ```python

  await led.rainbow_cycle(duration_per_color=5.0)


  await led.strobe_light(color=(255, 255, 255), duration=5.0, flashes=10)
  ```


  The library also provides a graphical user interface (GUI) built with PyQt6 to visually control the lights.

  To launch the GUI:

  ```bash
  python -m bluelights.gui.app
  ```

  The GUI includes sliders to adjust RGB values and buttons to control the lights and apply effects like fading and color cycling.


  You can configure your setup using an .env file to store your MohuanLED light’s MAC address and UUID.

  Create a .env file in the project directory with the following structure:

  ```bash
  LED_MAC_ADDRESS=xx:xx:xx:xx:xx:xx
  LED_UUID=0000xxxx-0000-1000-8000-00805f9b34fb
  ```
  The library will automatically load these values when you instantiate the LEDs.


  If you want to contribute or modify the project, you can set up the development environment as follows:

  Clone the repository:

  ```bash
  git clone https://github.com/Walkercito/MohuanLED-Bluetooth_LED
  ```
  Install the dependencies:

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


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


  - Bleak: For Bluetooth Low Energy (BLE) device control 🔗
  - PyQt6: For creating the graphical interface 🖼️
  - asyncio: For asyncronus tasks
  - qasync: For handling asynchronous processes in PyQt6 ⚡
  - python-dotenv: For auto-loading of LED_MAC_ADDRESS and LED_UUID in case of a `.env` file
  - nest_asyncio: For asyncio control


pkgId: 970f215aa77f425cad29a1bc0520357fbe25ba3e7393436289f6dc43e04bc3c7
name: python-BlurGenerator
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Fast generate blur image.
url: https://github.com/NatLee/Blur-Generator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BlurGenerator-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)[![PyPI implementation](https://img.shields.io/pypi/implementation/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)

  [![Test](https://github.com/NatLee/Blur-Generator/actions/workflows/test.yml/badge.svg)](https://github.com/NatLee/Blur-Generator/actions/workflows/test.yml)[![Release](https://github.com/NatLee/Blur-Generator/actions/workflows/release.yml/badge.svg)](https://github.com/NatLee/Blur-Generator/actions/workflows/release.yml)

  [![PyPI status](https://img.shields.io/pypi/status/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)[![PyPI license](https://img.shields.io/pypi/l/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)

  [![PyPI version fury.io](https://badge.fury.io/py/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)

  [![PyPI download month](https://img.shields.io/pypi/dm/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)[![PyPI download week](https://img.shields.io/pypi/dw/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)[![PyPI download day](https://img.shields.io/pypi/dd/BlurGenerator.svg)](https://pypi.python.org/pypi/BlurGenerator/)

  [![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)

  This tool is for generating blur on images.

  There are 3 types of blur modes of `motion`, `lens`, or `gaussian`.

  We can use the results on model training or something else.

  > You can find a simply use case with deep learning in https://github.com/NatLee/simply-blur-detector



  ```bash
  pip install blurgenerator
  ```

  Check it on [Pypi](https://pypi.org/project/BlurGenerator/).



  ```bash
  blurgenerator --help
  ```

  ```bash
  usage: blurgenerator [-h] [--input INPUT] [--input_depth_map INPUT_DEPTH_MAP] [--output OUTPUT] [--type TYPE] [--motion_blur_size MOTION_BLUR_SIZE] [--motion_blur_angle MOTION_BLUR_ANGLE] [--lens_radius LENS_RADIUS] [--lens_components LENS_COMPONENTS]
                       [--lens_exposure_gamma LENS_EXPOSURE_GAMMA] [--gaussian_kernel GAUSSIAN_KERNEL] [--depth_num_layers DEPTH_NUM_LAYERS] [--depth_min_blur DEPTH_MIN_BLUR] [--depth_max_blur DEPTH_MAX_BLUR]
                          Size for motion blur. Default is 100.
    --motion_blur_angle MOTION_BLUR_ANGLE
                          Angle for motion blur. Default is 30.
    --lens_radius LENS_RADIUS
                          Radius for lens blur. Default is 5.0.
    --lens_components LENS_COMPONENTS
                          Components for lens blur. Default is 4.
    --lens_exposure_gamma LENS_EXPOSURE_GAMMA
                          Exposure gamma for lens blur. Default is 2.
    --gaussian_kernel GAUSSIAN_KERNEL
                          Kernel for gaussian. Default is 100.
    --depth_num_layers DEPTH_NUM_LAYERS
                          Layer for depth blur. Default is 3.
    --depth_min_blur DEPTH_MIN_BLUR
                          Min. blur for depth blur. Default is 1.
    --depth_max_blur DEPTH_MAX_BLUR
                          Max. blur for depth blur. Default is 100.
  ```





  - Original image

  ![original image](https://github.com/NatLee/Blur-Generator/raw/main/doc/test.png)



  - Motion blur

  `blurgenerator --type motion --input ./doc/test.png --output ./doc/motion.png`

  ```python
  import cv2
  from blurgenerator import motion_blur
  img = cv2.imread('test.png')
  result = motion_blur(img, size=100, angle=30)
  cv2.imwrite('./output.png', result)
  ```

  ![motion blur image](https://github.com/NatLee/Blur-Generator/raw/main/doc/motion.png)

  - Lens blur

  `blurgenerator --type lens --input ./doc/test.png --output ./doc/lens.png`

  ```python
  import cv2
  from blurgenerator import lens_blur
  img = cv2.imread('test.png')
  result = lens_blur(img, radius=5, components=4, exposure_gamma=2)
  cv2.imwrite('./output.png', result)
  ```

  ![lens blur image](https://github.com/NatLee/Blur-Generator/raw/main/doc/lens.png)

  - Gaussian blur

  `blurgenerator --type gaussian --input ./doc/test.png --output ./doc/gaussian.png`

  ```python
  import cv2
  from blurgenerator import gaussian_blur
  img = cv2.imread('test.png')
  result = gaussian_blur(img, 100)
  cv2.imwrite('./output.png', result)
  ```

  ![gaussian blur image](https://github.com/NatLee/Blur-Generator/raw/main/doc/gaussian.png)



  Feature from this [issue](https://github.com/NatLee/Blur-Generator/issues/1).

  - Original image

  ![photo](https://github.com/NatLee/Blur-Generator/raw/main/doc/depth-test.jpg)

  - Depth map

  ![depth map](https://github.com/NatLee/Blur-Generator/raw/main/doc/depth-map-test.png)



  - Motion blur with depth map

  `blurgenerator --input .\doc\depth-test.jpg --type motion --input_depth_map .\doc\depth-map-test.png --depth_num_layers 5 --depth_min_blur 1 --depth_max_blur 50 --output .\doc\depth-motion-output.png`

  ```python
  import cv2
  from blurgenerator import motion_blur_with_depth_map
  img = cv2.imread('test.jpg')
  depth_img = cv2.imread('test-depth.png')
  result = motion_blur_with_depth_map(
     img,
     depth_map=depth_img,
     angle=30,
     num_layers=10,
     min_blur=1,
     max_blur=50
  )
  cv2.imwrite('./output.png', result)
  ```

  ![depth motion blur image](https://github.com/NatLee/Blur-Generator/raw/main/doc/depth-motion-output.png)

  - Lens blur with depth map

  `blurgenerator --input .\doc\depth-test.jpg --type lens --input_depth_map .\doc\depth-map-test.png --depth_num_layers 3 --depth_min_blur 1 --depth_max_blur 50 --output .\doc\depth-lens-output.png`

  ```python
  import cv2
  from blurgenerator import lens_blur_with_depth_map
  img = cv2.imread('test.jpg')
  depth_img = cv2.imread('test-depth.png')
  result = lens_blur_with_depth_map(
     img,
     depth_map=depth_img,
     components=5,
     exposure_gamma=5,
     num_layers=10,
     min_blur=1,
     max_blur=50
  )
  cv2.imwrite('./output.png', result)
  ```

  ![depth lens blur image](https://github.com/NatLee/Blur-Generator/raw/main/doc/depth-lens-output.png)

  - Gaussian blur with depth map

  `blurgenerator --input .\doc\depth-test.jpg --type gaussian --input_depth_map .\doc\depth-map-test.png --depth_num_layers 3 --depth_min_blur 1 --depth_max_blur 50 --output .\doc\depth-gaussian-output.png`

  ```python
  import cv2
  from blurgenerator import gaussian_blur_with_depth_map
  img = cv2.imread('test.jpg')
  depth_img = cv2.imread('test-depth.png')
  result = gaussian_blur_with_depth_map(
     img,
     depth_map=depth_img,
     sigma=5,
     num_layers=10,
     min_blur=1,
     max_blur=50
  )
  cv2.imwrite('./output.png', result)
  ```

  ![depth gaussian blur image](https://github.com/NatLee/Blur-Generator/raw/main/doc/depth-gaussian-output.png)



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center"><a href="https://github.com/NatLee"><img src="https://avatars.githubusercontent.com/u/10178964?v=3?s=100" width="100px;" alt="Nat Lee"/><br /><sub><b>Nat Lee</b></sub></a></td>
      </tr>
    </tbody>
  </table>

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

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



  - [Circularly symmetric convolution and lens blur](http://yehar.com/blog/?p=1495)




  [MIT](LICENSE)


pkgId: ffecfb5093dfda0fef77c332518a7a59a0609927465f2c540571a295e61623df
name: python-BnPreprocessing
arch: src
version: 2.9
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Kowsher/Bangla-NLP/tree/master/Bangla%20Feature%20Extraction
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BnPreprocessing-2.9-1.src.rpm
checksum_type: sha256
description:
  This page gives a basic introduction to the package.

  ```
  pip install BnPreprocessing
  ```
  In Python a Bangla Linga is typically written as:

  ```python
  import BnPreprocessing as pp
  s =  "আমরা কাজ করবো কিভাবে!!😦😦 । Document তৈরী করতে আমাদের সবাইকে কি করতে হবে? ৫-৬ জন আমরা, কঠিন হবে :("
  s = pp.remove_punc(s)
  print(s)
  s = pp.remove_digits(s)
  print(s)
  s = pp.remove_nonBangla(s)
  print(s)
  s = pp.remove_emoticons(s)
  print(s)
  s = pp.remove_sw(s)
  print(s)
  ```
  Output:
  ```
  আমরা কাজ করবো কিভাবে  😦😦   Document তৈরী করতে আমাদের সবাইকে কি করতে হবে  ৫ ৬ জন আমরা  কঠিন হবে
  আমরা কাজ করবো কিভাবে  😦😦   Document তৈরী করতে আমাদের সবাইকে কি করতে হবে    জন আমরা  কঠিন হবে
  আমরা কাজ করবো কিভাবে  😦😦    তৈরী করতে আমাদের সবাইকে কি করতে হবে    জন আমরা  কঠিন হবে
  আমরা কাজ করবো কিভাবে      তৈরী করতে আমাদের সবাইকে কি করতে হবে    জন আমরা  কঠিন হবে
  করবো কিভাবে তৈরী সবাইকে কঠিন
  ```
  If you want to do all the preprocessings in one step:

  ```python
  import BnPreprocessing as pp
  s =  "আমরা কাজ করবো কিভাবে!!😦😦 । Document তৈরী করতে আমাদের সবাইকে কি করতে হবে? ৫-৬ জন আমরা, কঠিন হবে :("
  s = pp.remove_noise(s)
  print(s)
  ```
  Output:
  ```
  করবো কিভাবে তৈরী সবাইকে কঠিন
  ```

  ```python
  import BnPreprocessing as pp

  df['Text'] = df['Text'].apply(pp.remove_noise) #use any of the functions above

  df['Text'] = df['Text'].apply(lambda x: pp.remove_noise(str(x)))
  ```


  ```python
  import BnPreprocessing as pp
  s = "2018 এর পরিসংখ্যান অনুযায়ী বাংলাদেশের জনসংখ্যা প্রায় 161.4 মিলিয়ন"
  s = pp.numETB(s)
  print(s)
  ```
  Output:
  ```
  ২০১৮ এর পরিসংখ্যান অনুযায়ী বাংলাদেশের জনসংখ্যা প্রায় ১৬১.৪ মিলিয়ন
  ```

  ```python
  import BnPreprocessing as pp
  s = "২০১৮ এর পরিসংখ্যান অনুযায়ী বাংলাদেশের জনসংখ্যা প্রায় ১৬১.৪ মিলিয়ন"
  s = pp.numBTE(s)
  print(s)
  ```
  Output:
  ```
  2018 এর পরিসংখ্যান অনুযায়ী বাংলাদেশের জনসংখ্যা প্রায় 161.4 মিলিয়ন
  ```


pkgId: 584f2b54eb826dd4085e831c22c9620127865970e346957909ea90a483b2833b
name: python-BoaHancock
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: This is tools to make starter template python for create moduls or library
url: https://github.com/Anammkh/BoaHancock
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BoaHancock-1.0.0-1.src.rpm
checksum_type: sha256
description:
  ![Logo](.github/boa.jpg)

  This is project to generate starter template for create moduls or library in python



  - Membuat struktur folder dasar untuk proyek Python, termasuk folder `src` dan `test`.
  - Menghasilkan file `LICENSE` berdasarkan jenis lisensi yang dipilih.
  - Menghasilkan file `README.md` dengan template dasar.
  - Membuat file `setup.py` yang telah dikonfigurasi untuk pengemasan proyek Python.
  - Menghasilkan file `.gitignore` untuk mengabaikan file yang tidak perlu.
  - Membuat file `__init__.py` di dalam folder `src` untuk modul Python.
  - Menyediakan berbagai pilihan lisensi seperti MIT, Apache, BSD-3-Clause, dan lainnya.


  ```bash
  pip install boaHancock --break-system-packages
  ```
  ```
  boa start
  ```


pkgId: 3c30e78e1eecb3a50f19eaa1f4140c5e23889418c741b37ffc48353ac686eec6
name: python-BoatBuddy
arch: src
version: 0.14.12
epoch: 0
release: 1
summary: A suite of tools to help collecting NMEA0183 and other marine metrics in a digital logbook format
url: https://boatbuddy.site
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BoatBuddy-0.14.12-1.src.rpm
checksum_type: sha256
description:
  [![Alt text](https://img.shields.io/pypi/v/boatbuddy.svg?style=flat-square)](https://pypi.python.org/pypi/boatbuddy/) [![Alt text](https://img.shields.io/github/license/joezeitouny/boatbuddy)](https://pypi.python.org/pypi/boatbuddy/)

  A suite of tools to help collecting NMEA0183 and other marine metrics in a digital logbook format.



  **Requirements:	Python 3.x >= 3.5**

  `BoatBuddy` can be installed via `pip` or an equivalent via:

  ```console
  $ pip install BoatBuddy
  ```



  You can install `BoatBuddy` from source just as you would install any other Python package:

  ```console
  $ pip install git+https://github.com/joezeitouny/BoatBuddy.git
  ```

  This will allow you to keep up to date with development on GitHub:

  ```console
  $ pip install -U git+https://github.com/joezeitouny/BoatBuddy.git
  ```



  - Ability to generate Excel and / or CSV logs
  - Generate GPX file with GPS coordinates combined with timestamps
  - Ability to generate a summary log for each session
  - Sessions can be tied by the NMEA server, Victron system availability or by a specified time interval



  ```console
  $ python -m BoatBuddy --config=CONFIGURATION_FILENAME [options]
  ```

  Where CONFIGURATION_FILENAME points to the file where the JSON configuration file is located on your system.

  For the full list of available options

  ```console
  $ python -m BoatBuddy --help
  ```


pkgId: 2ffb501036f41988caf3ffca73f49e98f3dfe5b05c5f2d9bfd9b2c7b5b53525c
name: python-BookingLibrary
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A simple booking management system.
url: https://pypi.org/project/BookingLibrary/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BookingLibrary-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A simple Python library for managing room bookings. It allows you to:

  Book a room and generate a unique booking ID.
  Cancel a booking using the booking ID.
  Retrieve the details of a booking using the booking ID.

  Features
  Book a Room: Create a new booking with a unique ID.
  Cancel a Booking: Cancel an existing booking by providing the booking ID.
  Get Booking Details: Retrieve the details of a booking using the booking ID.

  Installation
  You can install the package from PyPI using pip:
  pip install booking-management

  License
  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 12413f41fe4bbbf70c5d4f7c826e08067c737bd674747f6182375cc76b325305
name: python-Boorunaut
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A taggable imageboard built in Django.
url: https://github.com/Boorunaut/Boorunaut
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Boorunaut-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/Boorunaut/Boorunaut.svg?branch=master)](https://travis-ci.com/Boorunaut/Boorunaut)

  ![Welcome page screenshot of Boorunaut](assets/PostListingScreenshot.png)

  Boorunaut is a taggable imageboard built in [Django](https://www.djangoproject.com). Based on [Danbooru](https://github.com/r888888888/danbooru).

  It is able to be used locally to categorize images, or ready to configure and deploy as a website.

  * [Source repository](https://github.com/Boorunaut/Boorunaut)
  * [Documentation](https://boorunaut.gitbook.io/docs/)



  * Posts;
  * Gallery system;
  * Tagging system, with aliases and implications;
  * Control panel, including mass renaming, hash banning, mod queue and more.



  If you are on a Linux-based system, you can simply run `INSTALL.sh` to automatically setup everything on a virtual environment locally.

  You can also check the documentation below for more detailed instructions on how to install the library and its requirements manually and on different systems.



  The project is mainly written in the Python programming language, so it's an essential requirement. In order to download it, you can visit [the official website](https://www.python.org/), download it and install it.

  On Linux you can just run the following command on the bash:

  ```bash
  sudo apt-get install python3
  ```

  Please check if `pip` was installed along it with the command:

  ```bash
  python3 -m pip --version
  ```

  If no errors occurred, then you are good.



  Now you need to have the python virtual environment installed on python in order to be able to create isolated local version of python on the desired directory. You just run the following on the bash:

  ```bash
  python3 -m pip install virtualenv
  ```



  Now you create a new virtual environment on the directory you your choosing. After nativating to the directory, let's say it's called `mynewbooru` for example. Inside it, you can run on bash:

  ```bash
  virtualenv env
  ```

  This command will create a new virtual environment called `env`.
  You need now to activate the environment before running any of the following commands (you also need to activate it every time you want to run the project, or else an error saying you don't have the libraries installed will occur).

  On Linux you run:

  ```bash
  source env/bin/activate
  ```

  On Windows you run:

  ```bash
  .\env\Scripts\activate
  ```

  Now the environment is activated, so you are running an local isolated version of python. Anything you install here will not affect the "global" python installed on your system.



  Finally, you can now install `Boorunaut` on your python environment:

  ```bash
  pip install Boorunaut
  ```

  And you can start a new your project with the command:

  ```bash
  boorunaut startproject mysite
  ```

  It will create a new project folder. You can enter it and run Django's (the underling tecnology behind Boorunaut) commands to initialize the website configuration. To enter the folder you can run:

  ```bash
  cd mysite
  ```

  Your project should have the following file structure:

  ```bash
  mynewbooru/
  ├── env/
  └── mysite/
      └── mysite
          ├── __init__.py
          └── ...
      ├── __init__.py
      └── manage.py
  ```

  Then you run the following commands:


  ```bash
  python manage.py migrate
  python manage.py createsuperuser
  python manage.py runserver
  ```

  Now your website should be running on the default `localhost:8000`. Type that into your browser and check it out your own Boorunaut main page!

  By default, the database is set to SQLite. For production, it is recommended to change it to another one, like PostgreSQL.


pkgId: 56cb17a846a71fcfcb62e57ce2ebb3010a2604de7ffde04e7a65a793851f8e24
name: python-BootLintBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'BootLintBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/BootLintBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BootLintBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Raise several common HTML mistakes in html files that are using
      Bootstrap in a fairly "vanilla" way. Vanilla Bootstrap's components/widgets
      require their parts of the DOM to conform to certain structures that is
      checked. Also, raises issues about certain <meta> tags, HTML5 doctype
      declaration, etc. to use bootstrap properly.

      For more about the analysis, check Bootlint
      <https://github.com/twbs/bootlint#bootlint>.


pkgId: facb1a8a897655edfee4ae230cdbee4e8d8a9125c58c22ee9bec3f8564754ea2
name: python-Bootstrap-Flask
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Bootstrap 4 & 5 helper for your Flask projects.
url: https://pypi.org/project/Bootstrap-Flask/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bootstrap-Flask-2.4.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - License](https://img.shields.io/pypi/l/bootstrap-flask)
  [![Current version on PyPI](https://img.shields.io/pypi/v/bootstrap-flask)](https://pypi.org/project/bootstrap-flask/)
  [![Build status](https://github.com/helloflask/bootstrap-flask/workflows/build/badge.svg)](https://github.com/helloflask/bootstrap-flask/actions)
  [![Coverage Status](https://coveralls.io/repos/github/helloflask/bootstrap-flask/badge.svg?branch=master)](https://coveralls.io/github/helloflask/bootstrap-flask?branch=master)
  [![Open Collective](https://img.shields.io/opencollective/all/bootstrap-flask)](https://opencollective.com/bootstrap-flask)

  Bootstrap-Flask is a collection of Jinja macros for Bootstrap 4 & 5 and Flask. It helps you to
  render Flask-related data and objects to Bootstrap markup HTML more easily:

  - Render Flask-WTF/WTForms form object to Bootstrap Form.
  - Render data objects (dict or class objects) to Bootstrap Table.
  - Render Flask-SQLAlchemy `Pagination` object to Bootstrap Pagination.
  - etc.




  ```
  $ pip install -U bootstrap-flask
  ```



  Register the extension:

  ```python
  from flask import Flask



  from flask_bootstrap import Bootstrap5

  app = Flask(__name__)
  bootstrap = Bootstrap5(app)
  ```

  Assuming you have a Flask-WTF form like this:

  ```python
  class LoginForm(FlaskForm):
      username = StringField('Username', validators=[DataRequired(), Length(1, 20)])
      password = PasswordField('Password', validators=[DataRequired(), Length(8, 150)])
      remember = BooleanField('Remember me')
      submit = SubmitField()
  ```

  Now with the `render_form` macro:

  ```html
  {% from 'bootstrap5/form.html' import render_form %}
  <html>
  <head>
  <!-- Bootstrap CSS -->
  </head>
  <body>

  <h2>Login</h2>
  {{ render_form(form) }}

  <!-- Bootstrap JS -->
  </body>
  </html>
  ```

  You will get a form like this with only one line code (i.e. `{{ render_form(form) }}`):

  ![form rendering](./docs/_static/form-example.png)

  When the validation fails, the error messages will be rendered with proper style:

  ![error form rendering](./docs/_static/error-form-example.png)

  Read the [Basic Usage](https://bootstrap-flask.readthedocs.io/en/stable/basic)
  docs for more details.




  https://bootstrap-flask-example.azurewebsites.net/




  If you find Bootstrap-Flask useful, please consider
  [donating today](https://opencollective.com/bootstrap-flask/donate). Your donation keeps
  Bootstrap-Flask maintained and updated with Bootstrap.




  - [Documentation](https://bootstrap-flask.readthedocs.io)
  - [Example Application](https://github.com/helloflask/bootstrap-flask/tree/master/examples)
  - [PyPI Releases](https://pypi.org/project/Bootstrap-Flask/)
  - [Changelog](https://github.com/helloflask/bootstrap-flask/blob/master/CHANGES.rst)
  - [Discussions](https://github.com/helloflask/bootstrap-flask/discussions)




  The Bootstrap 5 support is added in Bootstrap-Flask 2.0 version. Now you can use
  the separate extension class for different Bootstrap major versions.

  For Bootstrap 4, use the `Bootstrap4` class:

  ```python
  from flask_bootstrap import Bootstrap4


  bootstrap = Bootstrap4(app)
  ```

  and import macros from the template path `bootstrap4/`:

  ```html
  {% from 'bootstrap4/form.html' import render_form %}
  ```

  For Bootstrap 5, use the `Bootstrap5` class:

  ```python
  from flask_bootstrap import Bootstrap5


  bootstrap = Bootstrap5(app)
  ```

  and import macros from the template path `bootstrap5/`:

  ```html
  {% from 'bootstrap5/form.html' import render_form %}
  ```

  The `Bootstrap` class and `bootstrap/` template path are deprecated since 2.0
  and will be removed in 3.0.




  If you come from Flask-Bootstrap, check out
  [this tutorial](https://bootstrap-flask.readthedocs.io/en/stable/migrate/) on how to
  migrate to this extension.




  For guidance on setting up a development environment and how to make a
  contribution to Bootstrap-Flask, see the
  [development documentation](https://bootstrap-flask.readthedocs.io/en/stable/#development)
  and Flask's
  [contributing guidelines](https://github.com/pallets/flask/blob/main/CONTRIBUTING.rst).




  This project is licensed under the MIT License (see the `LICENSE` file for
  details). Some macros were part of Flask-Bootstrap and were modified under
  the terms of its BSD License.


pkgId: 435c0e56deb45a4426a9d98aa3347e49f6f980bd9e8a3a64d41d2ef260257f7d
name: python-Bootstrap-Flask
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Bootstrap 4 & 5 helper for your Flask projects.
url: https://pypi.org/project/Bootstrap-Flask/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bootstrap-Flask-2.4.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - License](https://img.shields.io/pypi/l/bootstrap-flask)
  [![Current version on PyPI](https://img.shields.io/pypi/v/bootstrap-flask)](https://pypi.org/project/bootstrap-flask/)
  [![Build status](https://github.com/helloflask/bootstrap-flask/workflows/build/badge.svg)](https://github.com/helloflask/bootstrap-flask/actions)
  [![Coverage Status](https://coveralls.io/repos/github/helloflask/bootstrap-flask/badge.svg?branch=main)](https://coveralls.io/github/helloflask/bootstrap-flask?branch=main)
  [![Open Collective](https://img.shields.io/opencollective/all/bootstrap-flask)](https://opencollective.com/bootstrap-flask)

  Bootstrap-Flask is a collection of Jinja macros for Bootstrap 4 & 5 and Flask. It helps you to
  render Flask-related data and objects to Bootstrap markup HTML more easily:

  - Render Flask-WTF/WTForms form object to Bootstrap Form.
  - Render data objects (dict or class objects) to Bootstrap Table.
  - Render Flask-SQLAlchemy `Pagination` object to Bootstrap Pagination.
  - etc.




  ```
  $ pip install -U bootstrap-flask
  ```



  Register the extension:

  ```python
  from flask import Flask



  from flask_bootstrap import Bootstrap5

  app = Flask(__name__)
  bootstrap = Bootstrap5(app)
  ```

  Assuming you have a Flask-WTF form like this:

  ```python
  class LoginForm(FlaskForm):
      username = StringField('Username', validators=[DataRequired(), Length(1, 20)])
      password = PasswordField('Password', validators=[DataRequired(), Length(8, 150)])
      remember = BooleanField('Remember me')
      submit = SubmitField()
  ```

  Now with the `render_form` macro:

  ```html
  {% from 'bootstrap5/form.html' import render_form %}
  <html>
  <head>
  <!-- Bootstrap CSS -->
  </head>
  <body>

  <h2>Login</h2>
  {{ render_form(form) }}

  <!-- Bootstrap JS -->
  </body>
  </html>
  ```

  You will get a form like this with only one line code (i.e. `{{ render_form(form) }}`):

  ![form rendering](./docs/_static/form-example.png)

  When the validation fails, the error messages will be rendered with proper style:

  ![error form rendering](./docs/_static/error-form-example.png)

  Read the [Basic Usage](https://bootstrap-flask.readthedocs.io/en/stable/basic)
  docs for more details.




  https://bootstrap-flask-example.azurewebsites.net/




  If you find Bootstrap-Flask useful, please consider
  [donating today](https://opencollective.com/bootstrap-flask/donate). Your donation keeps
  Bootstrap-Flask maintained and updated with Bootstrap.




  - [Documentation](https://bootstrap-flask.readthedocs.io)
  - [Example Application](https://github.com/helloflask/bootstrap-flask/tree/main/examples)
  - [PyPI Releases](https://pypi.org/project/Bootstrap-Flask/)
  - [Changelog](https://github.com/helloflask/bootstrap-flask/blob/main/CHANGES.rst)
  - [Discussions](https://github.com/helloflask/bootstrap-flask/discussions)




  The Bootstrap 5 support is added in Bootstrap-Flask 2.0 version. Now you can use
  the separate extension class for different Bootstrap major versions.

  For Bootstrap 4, use the `Bootstrap4` class:

  ```python
  from flask_bootstrap import Bootstrap4


  bootstrap = Bootstrap4(app)
  ```

  and import macros from the template path `bootstrap4/`:

  ```html
  {% from 'bootstrap4/form.html' import render_form %}
  ```

  For Bootstrap 5, use the `Bootstrap5` class:

  ```python
  from flask_bootstrap import Bootstrap5


  bootstrap = Bootstrap5(app)
  ```

  and import macros from the template path `bootstrap5/`:

  ```html
  {% from 'bootstrap5/form.html' import render_form %}
  ```

  The `Bootstrap` class and `bootstrap/` template path are deprecated since 2.0
  and will be removed in 3.0.




  If you come from Flask-Bootstrap, check out
  [this tutorial](https://bootstrap-flask.readthedocs.io/en/stable/migrate/) on how to
  migrate to this extension.




  For guidance on setting up a development environment and how to make a
  contribution to Bootstrap-Flask, see the
  [development documentation](https://bootstrap-flask.readthedocs.io/en/stable/#development)
  and Flask's
  [contributing guidelines](https://github.com/pallets/flask/blob/main/CONTRIBUTING.rst).




  This project is licensed under the MIT License (see the `LICENSE` file for
  details). Some macros were part of Flask-Bootstrap and were modified under
  the terms of its BSD License.


pkgId: 48d04249c575c12be8a6529b7944cc5ec7dd565236a6b63a66d528496108f81f
name: python-Boruta
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Python Implementation of Boruta Feature Selection
url: https://github.com/danielhomola/boruta_py
rpm_license: BSD 3 clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Boruta-0.4.3-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/scikit-learn-contrib/boruta_py)](https://github.com/scikit-learn-contrib/boruta_py/blob/master/LICENSE)
  [![PyPI version](https://badge.fury.io/py/Boruta.svg)](https://badge.fury.io/py/Boruta)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/boruta_py/badges/version.svg)](https://anaconda.org/conda-forge/boruta_py)

  This project hosts Python implementations of the [Boruta all-relevant feature selection method](https://www.jstatsoft.org/article/view/v036i11).

  [Related blog post](https://danielhomola.com/feature%20selection/phd/borutapy-an-all-relevant-feature-selection-method/)




  Install with `pip`:

  ```shell
  pip install Boruta
  ```

  or with `conda`:

  ```shell
  conda install -c conda-forge boruta_py
  ```



  * numpy
  * scipy
  * scikit-learn



  Download, import and do as you would with any other scikit-learn method:
  * fit(X, y)
  * transform(X)
  * fit_transform(X, y)



  Python implementations of the Boruta R package.

  This implementation tries to mimic the scikit-learn interface, so use fit,
  transform or fit_transform, to run the feature selection.

  For more, see the docs of these functions, and the examples below.

  [Original code](https://gitlab.com/mbq/Boruta) and method was authored by Miron B. Kursa.

  Boruta is an all relevant feature selection method, while most other are
  minimal optimal; this means it tries to find all features carrying
  information usable for prediction, rather than finding a possibly compact
  subset of features on which some classifier has a minimal error.

  Why bother with all relevant feature selection?
  When you try to understand the phenomenon that made your data, you should
  care about all factors that contribute to it, not just the bluntest signs
  of it in context of your methodology (yes, minimal optimal set of features
  by definition depends on your classifier choice).




  It is the original R package recoded in Python with a few added extra features.
  Some improvements include:

  * Faster run times, thanks to scikit-learn

  * Scikit-learn like interface

  * Compatible with any ensemble method from scikit-learn

  * Automatic n_estimator selection

  * Ranking of features

  * Feature importances are derived from Gini impurity instead of RandomForest R package's MDA.

  For more details, please check the top of the docstring.

  We highly recommend using pruned trees with a depth between 3-7.

  Also, after playing around a lot with the original code I identified a few areas
  where the core algorithm could be improved/altered to make it less strict and
  more applicable to biological data, where the Bonferroni correction might be
  overly harsh.

  __Percentile as threshold__
  The original method uses the maximum of the shadow features as a threshold in
  deciding which real feature is doing better than the shadow ones. This could be
  overly harsh.

  To control this, I added the perc parameter, which sets the
  percentile of the shadow features' importances, the algorithm uses as the
  threshold. The default of 100 which is equivalent to taking the maximum as the
  R version of Boruta does, but it could be relaxed. Note, since this is the
  percentile, it changes with the size of the dataset. With several thousands of
  features it isn't as stringent as with a few dozens at the end of a Boruta run.


  __Two step correction for multiple testing__
  The correction for multiple testing was relaxed by making it a two step
  process, rather than a harsh one step Bonferroni correction.

  We need to correct firstly because in each iteration we test a number of
  features against the null hypothesis (does a feature perform better than
  expected by random). For this the Bonferroni correction is used in the original
  code which is known to be too stringent in such scenarios (at least for
  biological data), and also the original code corrects for n features, even if
  we are in the 50th iteration where we only have k<<n features left. For this
  reason the first step of correction is the widely used Benjamini Hochberg FDR.

  Following that however we also need to account for the fact that we have been
  testing the same features over and over again in each iteration with the
  same test. For this scenario the Bonferroni is perfect, so it is applied by
  dividing the p-value threshold with the current iteration index.

  If this two step correction is not required, the two_step parameter has to be
  set to False, then (with perc=100) BorutaPy behaves exactly as the R version.



  __estimator__ : object
     > A supervised learning estimator, with a 'fit' method that returns the
     > feature_importances_ attribute. Important features must correspond to
     > high absolute values in the feature_importances_.

  __n_estimators__ : int or string, default = 1000
     > If int sets the number of estimators in the chosen ensemble method.
     > If 'auto' this is determined automatically based on the size of the
     > dataset. The other parameters of the used estimators need to be set
     > with initialisation.

  __perc__ : int, default = 100
     > Instead of the max we use the percentile defined by the user, to pick
     > our threshold for comparison between shadow and real features. The max
     > tends to be too stringent. This provides a finer control over this. The
     > lower perc is the more false positives will be picked as relevant but
     > also the less relevant features will be left out. The usual trade-off.
     > The default is essentially the vanilla Boruta corresponding to the max.

  __alpha__ : float, default = 0.05
     > Level at which the corrected p-values will get rejected in both correction
     steps.

  __two_step__ : Boolean, default = True
    > If you want to use the original implementation of Boruta with Bonferroni
    > correction only set this to False.

  __max_iter__ : int, default = 100
     > The number of maximum iterations to perform.

  __verbose__ : int, default=0
     > Controls verbosity of output.




  **n_features_** : int
     > The number of selected features.

  **support_** : array of shape [n_features]
     > The mask of selected features - only confirmed ones are True.

  **support_weak_** : array of shape [n_features]
    >  The mask of selected tentative features, which haven't gained enough
    >  support during the max_iter number of iterations..

  **ranking_** : array of shape [n_features]
    >  The feature ranking, such that ``ranking_[i]`` corresponds to the
    >  ranking position of the i-th feature. Selected (i.e., estimated
    >  best) features are assigned rank 1 and tentative features are assigned
    >  rank 2.




  [![Open example notebook](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/https://raw.githubusercontent.com/scikit-learn-contrib/boruta_py/master/boruta/examples/Madalon_Data_Set.ipynb)
  [![Open example notebook](https://b.mineo.app/static/img/open_in_mineo.svg)](https://b.mineo.app/import/https://raw.githubusercontent.com/scikit-learn-contrib/boruta_py/master/boruta/examples/Madalon_Data_Set.ipynb)

  ```python
  import pandas as pd
  from sklearn.ensemble import RandomForestClassifier
  from boruta import BorutaPy



  X = pd.read_csv('examples/test_X.csv', index_col=0).values
  y = pd.read_csv('examples/test_y.csv', header=None, index_col=0).values
  y = y.ravel()



  rf = RandomForestClassifier(n_jobs=-1, class_weight='balanced', max_depth=5)


  feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=1)


  feat_selector.fit(X, y)


  feat_selector.support_


  feat_selector.ranking_


  X_filtered = feat_selector.transform(X)
  ```



  1. Kursa M., Rudnicki W., "Feature Selection with the Boruta Package" Journal of Statistical Software, Vol. 36, Issue 11, Sep 2010


pkgId: 84489886e66775d36c2d3154adf342394c26a6e1c9180da01e147374b1d2ceb4
name: python-BorutaShap
arch: src
version: 1.0.17
epoch: 0
release: 1
summary: A feature selection algorithm.
url: https://github.com/Ekeany/Boruta-Shap
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BorutaShap-1.0.17-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/255354538.svg)](https://zenodo.org/badge/latestdoi/255354538)
  <a href="https://badge.fury.io/py/BorutaShap"><img src="https://badge.fury.io/py/BorutaShap.svg" alt="PyPI version" height="18"></a>


  BorutaShap is a wrapper feature selection method which combines both the Boruta feature selection algorithm with shapley values. This combination has proven to out perform the original Permutation Importance method in both speed, and the quality of the feature subset produced. Not only does this algorithm provide a better subset of features, but it can also simultaneously provide the most accurate and consistent global feature rankings which can be used for model inference too. Unlike the orginal R package, which limits the user to a Random Forest model, BorutaShap allows the user to choose any Tree Based learner as the base model in the feature selection process.

  Despite BorutaShap's runtime improvements the SHAP TreeExplainer scales linearly with the number of observations making it's use cumbersome for large datasets. To combat this, BorutaShap includes a sampling procedure which uses the smallest possible subsample of the data availble at each iteration of the algorithm. It finds this sample by comparing the distributions produced by an isolation forest of the sample and the data using ks-test. From experiments, this procedure can reduce the run time up to 80% while still creating a valid approximation of the entire data set. Even with these improvments the user still might want a faster solution so BorutaShap has included an option to use the mean decrease in gini impurity. This importance measure is independent of the size dataset as it uses the tree's structure to compute a global feature ranking making it much faster than SHAP at larger datasets. Although this metric returns somewhat comparable feature subsets, it is not a reliable measure of global feature importance in spite of it's wide spread use. Thus, I would recommend to using the SHAP metric whenever possible.



  1. Start by creating new copies of all the features in the data set and name them shadow + feature_name, shuffle these newly added features to remove their correlations with the response variable.

  2. Run a classifier on the extended data with the random shadow features included. Then rank the features using a feature importance metric the original algorithm used permutation importance as it's metric of choice.

  3. Create a threshold using the maximum importance score from the shadow features. Then assign a hit to any feature that had exceeded this threshold.

  4. For every unassigned feature preform a two sided T-test of equality.

  5. Attributes which have an importance significantly lower than the threshold are deemed 'unimportant' and are removed them from process. Deem the attributes which have importance significantly higher than than the threshold as 'important'.

  6. Remove all shadow attributes and repeat the procedure until an importance has been assigned for each feature, or the algorithm has reached the previously set limit of runs.

  If the algorithm has reached its set limit of runs and an importance has not been assigned to each feature the user has two choices. Either increase the number of runs or use the tentative rough fix function which compares the median importance values between unassigned features and the maximum shadow feature to make the decision.





  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BorutaShap.

  ```bash
  pip install BorutaShap
  ```



  For more use cases such as alternative models, sampling or changing the importance metric please view the notebooks [here](https://github.com/Ekeany/Boruta-Shap/tree/master/Examples).


  ```python
  from BorutaShap import BorutaShap, load_data

  X, y = load_data(data_type='regression')
  X.head()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonHead.PNG?raw=true" height="203" width="722">

  ```python

  Feature_Selector = BorutaShap(importance_measure='shap',
                                classification=False)

  '''
  Sample: Boolean
  	if true then a rowise sample of the data will be used to calculate the feature importance values

  sample_fraction: float
  	The sample fraction of the original data used in calculating the feature importance values only
          used if Sample==True.

  train_or_test: string
  	Decides whether the feature improtance should be calculated on out of sample data see the dicussion here.
          https://slds-lmu.github.io/iml_methods_limitations/pfi-data.html

  normalize: boolean
              if true the importance values will be normalized using the z-score formula

  verbose: Boolean
  	a flag indicator to print out all the rejected or accepted features.
  '''
  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonOutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/Bostonplot.PNG?raw=true" height="530" width="699">

  ```python

  subset = Feature_Selector.Subset()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/bostonsubset.PNG?raw=true" height="194" width="465">




  ```python
  from BorutaShap import BorutaShap, load_data
  from xgboost import XGBClassifier

  X, y = load_data(data_type='classification')
  X.head()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryhead.PNG?raw=true">

  ```python
  model = XGBClassifier()


  Feature_Selector = BorutaShap(model=model,
                                importance_measure='shap',
                                classification=True)

  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryoutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryplot.PNG?raw=true" height="565" width="671">

  ```python

  subset = Feature_Selector.Subset()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binarysubset.PNG?raw=true">


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


  If you wish to cite this work please click on the zenodo badge at the top of this READme file
  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: f3bfab9830cd8d172a1fe1ddff7f5001b923a8d882b582d022eff04874876cae
name: python-BotAmino
arch: src
version: 1.28.1
epoch: 0
release: 1
summary: A library to create Amino bots.
url: https://github.com/ThePhoenix78/AminoBot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BotAmino-1.28.1-1.src.rpm
checksum_type: sha256
description:
  An API for bot amino based on Slimakoi's work

  Discord server https://discord.gg/KZgKktQ6Rt

  This API has been made for people who aren't very good at programming or people who want to do easy stuff!



  It works like the Amino.py's API but with added features like commands or answer
  for example:

  ```python3
  from BotAmino import BotAmino, Parameters

  print("wait...")
  client = BotAmino("email", "password")
  client.prefix = "/"  # set the prefix to /
  client.wait = 10  # wait 10 sec before doing a new command


  def test(data: Parameters):
      return data.authorId in ["your_user_id", "friend_user_id"]


  @client.command("ping", test) # "ping" the command and test the function, if test is True the command will be executed, else it will not
  def ping(data: Parameters):
      data.subClient.send_message(data.chatId, message="pong!")


  @client.command("pong") # "pong" the command, the test function is not necessary
  def pong(data: Parameters):
      if data.subClient.is_in_staff(data.authorId): # will execute the command if the user is in the amino's staff (learder/curator)
          data.subClient.send_message(data.chatId, message="ping!")


  @client.answer("hey")
  def hello(data: Parameters):
      data.subClient.send_message(data.chatId, message="Hey! Hey!")


  @client.on_member_join_chat()
  def say_hello(data: Parameters):
      data.subClient.send_message(data.chatId, f"welcome here {data.author}!")


  @client.on_member_leave_chat(["chatId"]) # the chatId is not necessary, put one if you want a specified chat only
  def say_goodbye(data: Parameters):
      data.subClient.send_message(data.chatId, f"See you soon {data.author}!")


  client.launch()
  print("ready")
  ```



  - add_title(userId, title, color) : add a title to an user

  - remove_title(userId, title) : remove the title given to the user

  - follow_user(userId) : follow the user in parameters

  - unfollow_user(userId) : unfollow the user in parameters

  - leave_all_chats() : leave all the chats for a given community

  - join_all_chat() : join all the publics chat of an Amino

  - get_chats() : return a list of the publics chatrooms

  - join_chatroom(chat_name_or_link) : join the chat for the given link/name

  - pay(nb_of_coins, blogId, chatId, objectId, transactionId) : give coins in balance, transactionId not necessary (automatically generated if not put)

  - get_wallet_amount() : return the number of coin of the bot

  - get_member_title(userId) : return the titles of the member

  - get_member_level(userId) : return the level of the member [1-20]

  - leave_community() : leave the current community

  - get_chat_id(chat) : return the id of the chat (link supported)

  - ask_amino_staff(message) : send the message to all the curators/leader of the amino

  - get_user_id(name_or_id) : return a tuple with the name and the userId (name, uid)

  - get_staff(community) : return the staff of the given community (communityId or aminoId)

  - accept_role(noticeId, chatId) : accept a promotion or a chat transfert

  - generate_transaction_id() : create a transactionId

  - ask_all_members(message) : will send a message in pv to all member by group of 100

  - is_it_bot(userId) : check if the user is the bot account

  - add_community("aminoId") : add manually a community to the bot (nice for join amino command)


pkgId: 9d32c8a2299ef0e1efc08b6c1aef9267826e424ec4f9ce2113f3f718ac1d8f6b
name: python-Botte
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: The most easiest telegram package that helps you to code your bot faster
url: https://github.com/Teameviral/botte
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Botte-0.6.2-1.src.rpm
checksum_type: sha256
description:
  * Installation using pip (a Python package manager):

  ```
  $ pip install botte==0.6.2
  ```

  *While the API is production-ready, it is still under development and it has regular updates, do not forget to update it regularly by calling*

  ```
  pip install botte --upgrade
  ```





  It is presumed that you [have obtained an API token with @BotFather](https://core.telegram.org/bots#botfather). We will call this token `TOKEN`.
  Furthermore, you have basic knowledge of the Python programming language and more importantly [the Telegram Bot API](https://core.telegram.org/bots/api).



  The Botte class (defined in \__init__.py) encapsulates all API calls in a single class. It provides functions such as `send_xyz` (`send_message`, `send_document` etc.) and several ways to listen for incoming messages.

  Create a file called `echo_bot.py`.
  Then, open the file and create an instance of the Botte class.
  ```python
  import Botte

  bot = Botte.Botte("TOKEN", parse_mode=None) # You can set parse_mode by default. HTML or MARKDOWN
  ```
  *Note: Make sure to actually replace TOKEN with your own API token.*

  After that declaration, we need to register some so-called message handlers. Message handlers define filters which a message must pass. If a message passes the filter, the decorated function is called and the incoming message is passed as an argument.

  Let's define a message handler which handles incoming `/start` and `/help` commands.
  ```python
  @bot.handle_msg(commands=['start', 'help'])
  def swagatam(message):
  	bot.reply_to(message, "Howdy, how are you doing?")
  ```
  A function which is decorated by a message handler __can have an arbitrary name, however, it must have only one parameter (the message)__.

  Let's add another handler:
  ```python
  @bot.handle_msg(func=lambda m: True)
  def echo_all(message):
  	bot.reply_to(message, message.text)
  ```
  This one echoes all incoming text messages back to the sender. It uses a lambda function to test a message. If the lambda returns True, the message is handled by the decorated function. Since we want all messages to be handled by this function, we simply always return True.

  *Note: all handlers are tested in the order in which they were declared*

  We now have a basic bot which replies a static message to "/start" and "/help" commands and which echoes the rest of the sent messages. To start the bot, add the following to our source file:
  ```python
  bot.runthebot()
  ```
  Alright, that's it! Our source file now looks like this:
  ```python
  import Botte

  bot = Botte.Botte("YOUR_BOT_TOKEN")

  @bot.handle_msg(commands=['start', 'help'])
  def swagatam(message):
  	bot.reply_to(message, "Howdy, how are you doing?")

  @bot.handle_msg(func=lambda message: True)
  def echo_all(message):
  	bot.reply_to(message, message.text)

  bot.runthebot()
  ```
  To start the bot, simply open up a terminal and enter `python echo_bot.py` to run the bot! Test it by sending commands ('/start' and '/help') and arbitrary text messages.





  All types are defined in types.py. They are all completely in line with the [Telegram API's definition of the types](https://core.telegram.org/bots/api#available-types), except for the Message's `from` field, which is renamed to `from_user` (because `from` is a Python reserved token). Thus, attributes such as `message_id` can be accessed directly with `message.message_id`. Note that `message.chat` can be either an instance of `User` or `GroupChat` (see [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)).

  The Message object also has a `content_type`attribute, which defines the type of the Message. `content_type` can be one of the following strings:
  `text`, `audio`, `document`, `animation`, `game`, `photo`, `sticker`, `video`, `video_note`, `voice`, `location`, `contact`, `venue`, `dice`, `new_chat_members`, `left_chat_member`, `new_chat_title`, `new_chat_photo`, `delete_chat_photo`, `group_chat_created`, `supergroup_chat_created`, `channel_chat_created`, `migrate_to_chat_id`, `migrate_from_chat_id`, `pinned_message`, `invoice`, `successful_payment`, `connected_website`, `poll`, `passport_data`, `proximity_alert_triggered`, `video_chat_scheduled`, `video_chat_started`, `video_chat_ended`, `video_chat_participants_invited`, `web_app_data`, `message_auto_delete_timer_changed`, `forum_topic_created`, `forum_topic_closed`, `forum_topic_reopened`, `forum_topic_edited`, `general_forum_topic_hidden`, `general_forum_topic_unhidden`, `write_access_allowed`, `user_shared`, `chat_shared`, `story`.

  You can use some types in one function. Example:

  ```content_types=["text", "sticker", "pinned_message", "photo", "audio"]```



  All [API methods](https://core.telegram.org/bots/api#available-methods) are located in the Botte class. They are renamed to follow common Python naming conventions. E.g. `getMe` is renamed to `get_me` and `sendMessage` to `send_message`.



  Outlined below are some general use cases of the API.


  A message handler is a function that is decorated with the `handle_msg` decorator of a Botte instance. Message handlers consist of one or multiple filters.
  Each filter must return True for a certain message in order for a message handler to become eligible to handle that message. A message handler is declared in the following way (provided `bot` is an instance of Botte):
  ```python
  @bot.handle_msg(filters)
  def function_name(message):
  	bot.reply_to(message, "This is a message handler")
  ```
  `function_name` is not bound to any restrictions. Any function name is permitted with message handlers. The function must accept at most one argument, which will be the message that the function must handle.
  `filters` is a list of keyword arguments.
  A filter is declared in the following manner: `name=argument`. One handler may have multiple filters.
  Botte supports the following filters:

  |name|argument(s)|Condition|
  |:---:|---| ---|
  |content_types|list of strings (default `['text']`)|`True` if message.content_type is in the list of strings.|
  |regexp|a regular expression as a string|`True` if `re.search(regexp_arg)` returns `True` and `message.content_type == 'text'` (See [Python Regular Expressions](https://docs.python.org/2/library/re.html))|
  |commands|list of strings|`True` if `message.content_type == 'text'` and `message.text` starts with a command that is in the list of strings.|
  |chat_types|list of chat types|`True` if `message.chat.type` in your filter|
  |func|a function (lambda or function reference)|`True` if the lambda or function reference returns `True`|

  Here are some examples of using the filters and message handlers:

  ```python
  import Botte
  bot = Botte.Botte("TOKEN")


  @bot.handle_msg(commands=['start', 'help'])
  def handle_start_help(message):
  	pass


  @bot.handle_msg(content_types=['document', 'audio'])
  def handle_docs_audio(message):
  	pass


  @bot.handle_msg(regexp="SOME_REGEXP")
  def handle_message(message):
  	pass


  @bot.handle_msg(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
  def handle_text_doc(message):
  	pass


  def test_message(message):
  	return message.document.mime_type == 'text/plain'

  @bot.handle_msg(func=test_message, content_types=['document'])
  def handle_text_doc(message):
  	pass



  @bot.handle_msg(commands=['hello'])
  @bot.handle_msg(func=lambda msg: msg.text.encode("utf-8") == SOME_FANCY_EMOJI)
  def send_something(message):
      pass
  ```
  **Important: all handlers are tested in the order in which they were declared**


  Handle edited messages
  `@bot.edited_handle_msg(filters) # <- passes a Message type object to your function`


  Handle channel post messages
  `@bot.channel_post_handler(filters) # <- passes a Message type object to your function`


  Handle edited channel post messages
  `@bot.edited_channel_post_handler(filters) # <- passes a Message type object to your function`


  Handle callback queries
  ```python
  @bot.callback_query_handler(func=lambda call: True)
  def test_callback(call): # <- passes a CallbackQuery type object to your function
      logger.info(call)
  ```


  Handle shipping queries
  `@bot.shipping_query_handler() # <- passes a ShippingQuery type object to your function`


  Handle pre checkoupt queries
  `@bot.pre_checkout_query_handler() # <- passes a PreCheckoutQuery type object to your function`


  Handle poll updates
  `@bot.poll_handler() # <- passes a Poll type object to your function`


  Handle poll answers
  `@bot.poll_answer_handler() # <- passes a PollAnswer type object to your function`


  Handle updates of a the bot's member status in a chat
  `@bot.my_chat_member_handler() # <- passes a ChatMemberUpdated type object to your function`


  Handle updates of a chat member's status in a chat
  `@bot.chat_member_handler() # <- passes a ChatMemberUpdated type object to your function`
  *Note: "chat_member" updates are not requested by default. If you want to allow all update types, set `allowed_updates` in `bot.polling()` / `bot.runthebot()` to `util.update_types`*


  Handle chat join requests using:
  `@bot.chat_join_request_handler() # <- passes ChatInviteLink type object to your function`



  More information about [Inline mode](https://core.telegram.org/bots/inline).



  Now, you can use inline_handler to get inline queries in Botte.

  ```python

  @bot.inline_handler(lambda query: query.query == 'text')
  def query_text(inline_query):
      
  ```



  Use chosen_inline_handler to get chosen_inline_result in Botte. Don't forgot add the /setinlinefeedback
  command for @Botfather.

  More information : [collecting-feedback](https://core.telegram.org/bots/inline#collecting-feedback)

  ```python
  @bot.chosen_inline_handler(func=lambda chosen_inline_result: True)
  def test_chosen(chosen_inline_result):
      
  ```



  ```python
  @bot.inline_handler(lambda query: query.query == 'text')
  def query_text(inline_query):
      try:
          r = types.InlineQueryResultArticle('1', 'Result', types.InputTextMessageContent('Result message.'))
          r2 = types.InlineQueryResultArticle('2', 'Result2', types.InputTextMessageContent('Result message2.'))
          bot.answer_inline_query(inline_query.id, [r, r2])
      except Exception as e:
          print(e)

  ```





  A middleware handler is a function that allows you to modify requests or the bot context as they pass through the
  Telegram to the bot. You can imagine middleware as a chain of logic connection handled before any other handlers are
  executed. Middleware processing is disabled by default, enable it by setting `apihelper.ENABLE_MIDDLEWARE = True`.

  ```python
  apihelper.ENABLE_MIDDLEWARE = True

  @bot.middleware_handler(update_types=['message'])
  def modify_message(bot_instance, message):
      
      message.another_text = message.text + ':changed'

  @bot.handle_msg(commands=['start'])
  def start(message):
      
      assert message.another_text == message.text + ':changed'
  ```
  There are other examples using middleware handler in the [examples/middleware](examples/middleware) directory.


  There are class-based middlewares.
  Basic class-based middleware looks like this:
  ```python
  class Middleware(BaseMiddleware):
      def __init__(self):
          self.update_types = ['message']
      def pre_process(self, message, data):
          data['foo'] = 'Hello' # just for example
          
          
          
      def post_process(self, message, data, exception=None):
          print(data['foo'])
          if exception: # check for exception
              print(exception)
  ```
  Class-based middleware should have two functions: post and pre process.
  So, as you can see, class-based middlewares work before and after handler execution.
  For more, check out in [examples](https://github.com/Kreaitorai/botte/tree/master/examples/middleware/class_based)


  Also, you can use built-in custom filters. Or, you can create your own filter.

  [Example of custom filter](https://github.com/Kreaitorai/botte/blob/master/examples/custom_filters/general_custom_filters.py)

  Also, we have examples on them. Check this links:

  You can check some built-in filters in source [code](https://github.com/Kreaitorai/botte/blob/master/Botte/custom_filters.py)

  Example of [filtering by id](https://github.com/Kreaitorai/botte/blob/master/examples/custom_filters/id_filter_example.py)

  Example of [filtering by text](https://github.com/Kreaitorai/botte/blob/master/examples/custom_filters/text_filter_example.py)

  If you want to add some built-in filter, you are welcome to add it in custom_filters.py file.

  Here is example of creating filter-class:

  ```python
  class IsAdmin(Botte.custom_filters.SimpleCustomFilter):
      
      key='is_chat_admin'
      @staticmethod
      def check(message: Botte.types.Message):
          return bot.get_chat_member(message.chat.id,message.from_user.id).status in ['administrator','creator']


  bot.add_custom_filter(IsAdmin())


  @bot.handle_msg(is_chat_admin=True)
  def admin_of_group(message):
  	bot.send_message(message.chat.id, 'You are admin of this group!')

  ```



  ```python
  import Botte

  TOKEN = '<token_string>'
  tb = Botte.Botte(TOKEN)	#create a new Telegram Bot object





  tb.runthebot(interval=0, timeout=20)


  user = tb.get_me()


  tb.set_webhook(url="http://example.com", certificate=open('mycert.pem'))

  tb.remove_webhook()


  updates = tb.get_updates()

  updates = tb.get_updates(1234,100,20) #get_Updates(offset, limit, timeout):


  tb.send_message(chat_id, text)


  tb.edit_message_text(new_text, chat_id, message_id)


  tb.forward_message(to_chat_id, from_chat_id, message_id)



  photo = open('/tmp/photo.png', 'rb')
  tb.send_photo(chat_id, photo)
  tb.send_photo(chat_id, "FILEID")


  audio = open('/tmp/audio.mp3', 'rb')
  tb.send_audio(chat_id, audio)
  tb.send_audio(chat_id, "FILEID")


  tb.send_audio(CHAT_ID, file_data, 1, 'Kreaitorai', 'pyTelegram')


  voice = open('/tmp/voice.ogg', 'rb')
  tb.send_voice(chat_id, voice)
  tb.send_voice(chat_id, "FILEID")


  doc = open('/tmp/file.txt', 'rb')
  tb.send_document(chat_id, doc)
  tb.send_document(chat_id, "FILEID")


  sti = open('/tmp/sti.webp', 'rb')
  tb.send_sticker(chat_id, sti)
  tb.send_sticker(chat_id, "FILEID")


  video = open('/tmp/video.mp4', 'rb')
  tb.send_video(chat_id, video)
  tb.send_video(chat_id, "FILEID")


  videonote = open('/tmp/videonote.mp4', 'rb')
  tb.send_video_note(chat_id, videonote)
  tb.send_video_note(chat_id, "FILEID")


  tb.send_location(chat_id, lat, lon)




  tb.send_chat_action(chat_id, action_string)




  import requests
  file_info = tb.get_file(file_id)

  file = requests.get('https://api.telegram.org/file/bot{0}/{1}'.format(API_TOKEN, file_info.file_path))


  ```

  All `send_xyz` functions of Botte take an optional `reply_markup` argument. This argument must be an instance of `ReplyKeyboardMarkup`, `ReplyKeyboardRemove` or `ForceReply`, which are defined in types.py.

  ```python
  from Botte import types









  markup = types.ReplyKeyboardMarkup(row_width=2)
  itembtn1 = types.KeyboardButton('a')
  itembtn2 = types.KeyboardButton('v')
  itembtn3 = types.KeyboardButton('d')
  markup.add(itembtn1, itembtn2, itembtn3)
  tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)


  markup = types.ReplyKeyboardMarkup()
  itembtna = types.KeyboardButton('a')
  itembtnv = types.KeyboardButton('v')
  itembtnc = types.KeyboardButton('c')
  itembtnd = types.KeyboardButton('d')
  itembtne = types.KeyboardButton('e')
  markup.row(itembtna, itembtnv)
  markup.row(itembtnc, itembtnd, itembtne)
  tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
  ```
  The last example yields this result:

  ![ReplyKeyboardMarkup](https://farm3.staticflickr.com/2933/32418726704_9ef76093cf_o_d.jpg "ReplyKeyboardMarkup")

  ```python


  markup = types.ReplyKeyboardRemove(selective=False)
  tb.send_message(chat_id, message, reply_markup=markup)
  ```

  ```python


  markup = types.ForceReply(selective=False)
  tb.send_message(chat_id, "Send me another word:", reply_markup=markup)
  ```
  ForceReply:

  ![ForceReply](https://farm4.staticflickr.com/3809/32418726814_d1baec0fc2_o_d.jpg "ForceReply")



  This object represents one special entity in a text message. For example, hashtags, usernames, URLs, etc.
  Attributes:
  * `type`
  * `url`
  * `offset`
  * `length`
  * `user`


  **Here's an Example:**`message.entities[num].<attribute>`<br>
  Here `num` is the entity number or order of entity in a reply, for if incase there are multiple entities in the reply/message.<br>
  `message.entities` returns a list of entities object. <br>
  `message.entities[0].type` would give the type of the first entity<br>
  Refer [Bot Api](https://core.telegram.org/bots/api#messageentity) for extra details




  Since version 5.0 of the Bot API, you have the possibility to run your own [Local Bot API Server](https://core.telegram.org/bots/api#using-a-local-bot-api-server).
  botte also supports this feature.
  ```python
  from Botte import apihelper

  apihelper.API_URL = "http://localhost:4200/bot{0}/{1}"
  ```
  **Important: Like described [here](https://core.telegram.org/bots/api#logout), you have to log out your bot from the Telegram server before switching to your local API server. in botte use `bot.log_out()`**

  *Note: 4200 is an example port*


  New: There is an asynchronous implementation of Botte.
  To enable this behaviour, create an instance of AsyncBotte instead of Botte.
  ```python
  tb = Botte.AsyncBotte("TOKEN")
  ```
  Now, every function that calls the Telegram API is executed in a separate asynchronous task.
  Using AsyncBotte allows you to do the following:
  ```python
  import Botte

  tb = Botte.AsyncBotte("TOKEN")

  @tb.handle_msg(commands=['start'])
  async def start_message(message):
  	await bot.send_message(message.chat.id, 'Hello!')

  ```

  See more in [examples](https://github.com/Kreaitorai/botte/tree/master/examples/asynchronous_Botte)


  Sometimes you must send messages that exceed 5000 characters. The Telegram API can not handle that many characters in one request, so we need to split the message in multiples. Here is how to do that using the API:
  ```python
  from Botte import util
  large_text = open("large_text.txt", "rb").read()



  splitted_text = util.split_string(large_text, 3000)

  for text in splitted_text:
  	tb.send_message(chat_id, text)
  ```

  Or you can use the new `smart_split` function to get more meaningful substrings:
  ```python
  from Botte import util
  large_text = open("large_text.txt", "rb").read()



  splitted_text = util.smart_split(large_text, chars_per_string=3000)
  for text in splitted_text:
  	tb.send_message(chat_id, text)
  ```

  The Botte constructor takes the following optional arguments:

   - threaded: True/False (default True). A flag to indicate whether
     Botte should execute message handlers on it's polling Thread.


  As an alternative to the message handlers, one can also register a function as a listener to Botte.

  NOTICE: handlers won't disappear! Your message will be processed both by handlers and listeners. Also, it's impossible to predict which will work at first because of threading. If you use threaded=False, custom listeners will work earlier, after them handlers will be called.
  Example:
  ```python
  def handle_messages(messages):
  	for message in messages:
  		
  		bot.reply_to(message, 'Hi')

  bot.set_update_listener(handle_messages)
  bot.runthebot()
  ```


  When using webhooks telegram sends one Update per call, for processing it you should call process_new_messages([update.message]) when you recieve it.

  There are some examples using webhooks in the [examples/webhook_examples](examples/webhook_examples) directory.


  You can use the Botte module logger to log debug info about Botte. Use `Botte.logger` to get the logger of the Botte module.
  It is possible to add custom logging Handlers to the logger. Refer to the [Python logging module page](https://docs.python.org/2/library/logging.html) for more info.

  ```python
  import logging

  logger = Botte.logger
  Botte.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
  ```


  For sync:

  You can use proxy for request. `apihelper.proxy` object will use by call `requests` proxies argument.

  ```python
  from Botte import apihelper

  apihelper.proxy = {'http':'http://127.0.0.1:3128'}
  ```

  If you want to use socket5 proxy you need install dependency `pip install requests[socks]` and make sure, that you have the latest version of `gunicorn`, `PySocks`, `botte`, `requests` and `urllib3`.

  ```python
  apihelper.proxy = {'https':'socks5://userproxy:password@proxy_address:port'}
  ```

  For async:
  ```python
  from Botte import asyncio_helper

  asyncio_helper.proxy = 'http://127.0.0.1:3128' #url
  ```



  You can disable or change the interaction with real Telegram server by using
  ```python
  apihelper.CUSTOM_REQUEST_SENDER = your_handler
  ```
  parameter. You can pass there your own function that will be called instead of _requests.request_.

  For example:
  ```python
  def custom_sender(method, url, **kwargs):
      print("custom_sender. method: {}, url: {}, params: {}".format(method, url, kwargs.get("params")))
      result = util.CustomRequestResponse('{"ok":true,"result":{"message_id": 1, "date": 1, "chat": {"id": 1, "type": "private"}}}')
      return result
  ```

  Then you can use API and proceed requests in your handler code.
  ```python
  apihelper.CUSTOM_REQUEST_SENDER = custom_sender
  tb = Botte("test")
  res = tb.send_message(123, "Test")
  ```

  Result will be:

  `custom_sender. method: post, url: https://api.telegram.org/botololo/sendMessage, params: {'chat_id': '123', 'text': 'Test'}`




  * ➕ [Bot API 4.5](https://core.telegram.org/bots/api-changelog#december-31-2019) - No nested MessageEntities and Markdown2 support
  * ➕ [Bot API 4.1](https://core.telegram.org/bots/api-changelog#august-27-2018)   - No Passport support
  * ➕ [Bot API 4.0](https://core.telegram.org/bots/api-changelog#july-26-2018)     - No Passport support




  We have a fully asynchronous version of Botte.
  This class is not controlled by threads. Asyncio tasks are created to execute all the stuff.


  Echo Bot example on AsyncBotte:

  ```python



  from Botte.async_Botte import AsyncBotte
  import asyncio
  bot = AsyncBotte('TOKEN')




  @bot.handle_msg(commands=['help', 'start'])
  async def swagatam(message):
      await bot.reply_to(message, """\
  Hi there, I am EchoBot.
  I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
  """)



  @bot.handle_msg(func=lambda message: True)
  async def echo_message(message):
      await bot.reply_to(message, message.text)


  asyncio.run(bot.polling())
  ```
  As you can see here, keywords are await and async.


  Asynchronous tasks depend on processor performance. Many asynchronous tasks can run parallelly, while thread tasks will block each other.


  AsyncBotte is asynchronous. It uses aiohttp instead of requests module.


  See more examples in our [examples](https://github.com/Kreaitorai/botte) folder





  Telegram Bot API support new type Chat for message.chat.

  - Check the ```type``` attribute in ```Chat``` object:
  ```python
  if message.chat.type == "private":
      

  if message.chat.type == "group":
  	

  if message.chat.type == "supergroup":
  	

  if message.chat.type == "channel":
  	

  ```



  Bot instances that were idle for a long time might be rejected by the server when sending a message due to a timeout of the last used session. Add `apihelper.SESSION_TIME_TO_LIVE = 5 * 60` to your initialisation to force recreation after 5 minutes without any activity.


pkgId: f6b1b877b63a05a0cb525dcfdf950c4889b5132cf4a3bd6a279ea24c6ab696bf
name: python-BottleSaml
arch: src
version: 22.8.27
epoch: 0
release: 1
summary: SAML Service Provider for Bottle
url: https://github.com/Glocktober/BottleSaml
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BottleSaml-22.8.27-1.src.rpm
checksum_type: sha256
description:
  **BottleSaml** is a Python module for the [Bottle web framework.](https://github.com/bottlepy/bottle) providing **SamlSP()** - [an implementation of a SAML *Service Provider* for **Bottle** web apps](docs/READMESP.md). This permits bottle apps to authenticated with a SAML Identity Provider (IdP).

  This module can be used on it's own, or combined with [BottleAuth](https://github.com/Glocktober/BottleAuth). BottleAuth provides path and route authentication and authorization tools.

  Both modules in **BottleSaml** rely on persistent *session* data in the form of a Python `dict` accessed off the Bottle **`request`** object (*i.e.* `request.session`). By default **BottleSaml** will use the [BottleSessions module](https://github.com/Glocktober/BottleSessions) to provide this - but any session middleware that can add a `session` dict to the `request` object can be used.

  The goal of this module is to provide easy to use tools for using SAML identity management platforms in Bottle apps.


pkgId: 7c9e98b614ee15c7c43451c342ffe02d9e6a45f627a09f8c19a29a6f5eaf05e3
name: python-BoydCut
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Thai Sentence Segmenter
url: https://github.com/BigDataRPG/BoydCut
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BoydCut-1.0.0-1.src.rpm
checksum_type: sha256
description:
  > Bidirectional LSTM-CNN Model for Thai Sentence Segmenter



  This project is the part of my Thesis in Master's degree at Big Data Engineering, CITE, Dhurakij Pundij University
  https://cite.dpu.ac.th/bigdata/


  **My Advisor**
  - Asst. Prof. Dr. Duangjai Jitkongchuen
  - Asst. Prof. Dr. Peerasak Intarapaiboon



  - Tensorflow 2.0+
  - Python 3.6.x
  - pip install -r requirements
  > if pip install -r requirements not work please follow Installation steps


  - pip install numpy pandas tensorflow
  - pip install deepcut
  - pip install pythainlp


  - pip install BoydCut
  - Version 1.0.0
  - [Notebook Example](https://colab.research.google.com/drive/1uMssc6RQQTeDhsja_aOWwLRl9Bjk31Qc?usp=sharing)
  ```
  boydcut = BoydCut()
  sent_ls = boydcut.sentenize("ประเทศฝรั่งเศสแผ่นดินใหญ่ทอดตัวตั้งแต่ทะเลเมดิเตอร์\
                                          เรเนียนจนถึงช่องแคบอังกฤษและทะเลเหนือ")
  for sent in sent_ls:
      print(sent)

  > <B-CLS>ประเทศฝรั่งเศส|แผ่นดิน|ใหญ่|ทอด|ตัว|ตั้งแต่|ทะเลเมดิเตอร์เรเนียน|จนถึง|ช่อง|แคบ<E-CLS>
  > <B-CLS>อังกฤษ|และ|ทะเล|เหนือ<E-CLS>


  boydcut = BoydCut()
  sent_ls = boydcut.sentenize(['ประเทศฝรั่งเศส','แผ่นดิน','ใหญ่','ทอดตัว','ตั้งแต่',
                              'ทะเลเมดิเตอร์เรเนียน','จนถึง','ช่อง','แคบ',
                              'อังกฤษ','และ','ทะเล','เหนือ'], _tokenize=False)
  for sent in sent_ls:
      print(sent)

  > <B-CLS>ประเทศฝรั่งเศส|แผ่นดิน|ใหญ่|ทอด|ตัว|ตั้งแต่|ทะเลเมดิเตอร์เรเนียน|จนถึง|ช่อง|แคบ<E-CLS>
  > <B-CLS>อังกฤษ|และ|ทะเล|เหนือ<E-CLS>
  ```


  - Document feeding is not available yet !
  - Max Word for feeding: 200 words / paragraph
  - Please use "\n" for decrease size of paragraph
  - Results: [sentence1, sentence2, sentence3,..., sentenceN]


  - POS apply pythainlp.tag.pos_tag(_sentence_ls, corpus="orchid")
  - Tokenization apply pythainlp.tokenize.word_tokenize(_text_ls, engine="deepcut")




  Sorratat Sirirattanajakarin (Boyd)

  - Youtube: https://youtube.com/c/BigDataRPG
  - Fanpage: https://www.facebook.com/bigdatarpg/
  - Medium: https://www.medium.com/bigdataeng
  - Github: https://www.github.com/BigDataRPG
  - Kaggle: https://www.kaggle.com/boydbigdatarpg
  - Linkedin: https://www.linkedin.com/in/boyd-sorratat
  - Twitter: https://twitter.com/BoydSorratat
  - GoogleScholar: https://scholar.google.com/citations?user=9cIeYAgAAAAJ&hl=en


  Please make sure to cite the paper if you use BoydCut for your research ^^:
  >**BoydCut: Bidirectional LSTM-CNN Model for Thai Sentence Segmenter**
  *S. Sirirattanajakarin, D. Jitkongchuen, P. Intarapaiboon* 2020 1st International Conference on Big Data Analytics and Practices (IBDAP)


pkgId: ba7ceac272932dbe3b99d3b07834e5be69ef993c6d1dca72f864a0f6f3cb59ad
name: python-Brain-Brew
arch: src
version: 0.3.11
epoch: 0
release: 1
summary: Automated Anki flashcard creation and extraction to/from Csv
url: https://github.com/ohare93/brain-brew
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Brain-Brew-0.3.11-1.src.rpm
checksum_type: sha256
description:
  <a title="Buy me a cuppa tea" href="https://ko-fi.com/brainbrew"><img src="https://img.shields.io/badge/ko--fi-contribute-%23579ebd.svg"></a>
  <a title="Support a fellow Weekend Warrior on Patreon" href="https://www.patreon.com/jmohare?fan_landing=true"><img src="https://img.shields.io/badge/patreon-support-%23f96854.svg"></a>

  Brain Brew is an open-source flashcard manipulation tool designed to allow users to convert their Anki flashcards to/from many different formats to suit their own needs.
  The goal is to facilitate collaboration and maximize user choice, with a powerful tool that minimizes effort.
  [CrowdAnki](https://github.com/Stvad/CrowdAnki) Exports and Csv(s) are the only supported file types as of now, but there will be more to come.


  [Anki Ultimate Geography](https://github.com/axelboc/anki-ultimate-geography/) is currently the best working example of a Flashcard repo using Brain Brew :tada:
  See there for inspiration!





  Install the latest version of [Brain Brew on PyPi.org](https://pypi.org/project/Brain-Brew/)
  with `pip install brain-brew`. Virtual environment using `pipenv` is recommended!

  :exclamation: See the [Brain Brew Starter Project][BrainBrewStarter] for a working clone-able Git repo.
  From this repo you can now create a functional Brain Brew setup automatically,
  with your own flashcards! Simply by running

  ```bash
  brainbrew init [Your CrowdAnki Export Folder]
  ```

  This will generate the entire working repo for you, including the recipe files, source files, and build folder.
  For bi-directional sync: Anki <-> Source!

  See [the starter repo][BrainBrewStarter] for a step-by-step guide for all of this.



  Brain Brew runs from the command line and takes a *Recipe.yaml* file to run.

  ```bash
  brainbrew run source_to_anki.yaml
  ```

  Full usage help text:
  ```bash
  Brain Brew vx.y.z
  usage: brainbrew [-h] {run,init} ...

  Manage Flashcards by transforming them to various types.

  positional arguments:
    {run,init}  Commands that can be run
      run       Run a recipe file. This will convert some data to another format, based on the instructions in the recipe file.
      init      Initialise a Brain Brew repository, using a CrowdAnki export as the base data.

  optional arguments:
    -h, --help  show this help message and exit
  ```




  These are the instructions for how Brain Brew will ~~build~~ *brew* your data into another format.

  What's YAML? See the current spec [here](http://www.yaml.org/spec/1.2/spec.html).

  Run a recipe with `--verify` or `-v` to confirm your recipe is valid, without actually running it.
  A dry run of sorts.



  A recipe is made of many individual tasks, which do specific functions.
  Full detailed list coming soon™️, but see the [Yamale recipe schema](https://github.com/ohare93/brain-brew/blob/master/brain_brew/schemas/recipe.yaml)
  (local file: `brain_brew/schemas/recipe.yaml`) in the meantime :+1:




  [//]: <> (Yamale)



  Brain Brew was made in an effort to solve some of the following issues with current collaboration of Anki Flashcards:



  Have some personal notes on your cards? Used some images randomly taken from the internet?
  That usually means you cannot share your deck entirely, without having to go to the effort of removing the offending material and/or managing two separate copies.



  Putting your cards into a source control system brings a lot of benefits.
  You can see any changes that occur, go back in time should an mistake be discovered, and collaborate with others.

  However the current tools for managing Anki cards in source control
  (such as [Anki-DM](https://github.com/OnkelTem/anki-dm), [GenAnki](https://github.com/kerrickstaley/genanki),
  and [Remote Decks](https://github.com/c-okelly/anki-remote-decks)) are only one way.
  You generate cards from a csv into a file that can *only be imported* into Anki.
  There is no way to export them back, meaning a user must manually copy their changes over, or simple not edit their cards anywhere other than in source control.

  This robs the user of two important work flows:
  1. Editing/fixing cards in Anki as you review them (on desktop or mobile)
  1. The plethora of Anki add-ons that already exist that are amazingly useful. E.g: Image Occlusion, Morphman, AwesomeTTS.

  A user should not have to pick between these fantastic work flows and the usage of source control to structure, manage, and share their cards.



  Csvs are great for editing data, but can only go so far by themselves. Having all the data inside one csv leaves a lot to be desired and can result in eventual problems.
  When one gets as many columns as *this* (from [Ultimate Geography](https://github.com/axelboc/anki-ultimate-geography/)) then it becomes a nightmare to manage:

  |guid|Country|Country:de|Country:es|Country:fr|Country:nb|"Country info"|"Country info:de"|"Country info:es"|"Country info:fr"|"Country info:nb"|Capital|Capital:de|Capital:es|Capital:fr|Capital:nb|"Capital info"|"Capital info:de"|"Capital info:es"|"Capital info:fr"|"Capital info:nb"|"Capital hint"|"Capital hint:de"|"Capital hint:es"|"Capital hint:fr"|"Capital hint:nb"|Flag|"Flag similarity"|"Flag similarity:de"|"Flag similarity:es"|"Flag similarity:fr"|"Flag similarity:nb"|Map|tags|
  | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
  |crr.AfnVRi|England|England|Inglaterra|Angleterre|England|"Constituent country of the United Kingdom."|"Landesteil des Vereinigten Königreichs."|"Nación constitutiva del Reino Unido."|"Nation constitutive du Royaume-Uni."|"Land som utgjør en del av Storbritannia."|London|London|Londres|Londres|London| | | | | |"Not a sovereign country"|"Kein souveräner Staat"|"No es un país soberano"|"Pas une nation souveraine"|"Ikke selvstendig land"|"<img src=""ug-flag-england.svg"" />"| | | | | |"<img src=""ug-map-england.png"" />"|UG::Europe|
  "h<B?Kff,?3"|"Ivory Coast"|Elfenbeinküste|"Costa de Marfil"|"Côte d’Ivoire"|Elfenbenskysten|"Officially Côte d'Ivoire."|"Offiziell Côte d'Ivoire."|"Oficialmente Côte d'Ivoire."| | |Yamoussoukro|Yamoussoukro|Yamusukro|Yamoussoukro|Yamoussoukro|"While Yamoussoukro is the official capital, Abidjan is the de facto seat of government."|"Yamoussoukro ist die offizielle Hauptstadt, aber Abidjan ist der Regierungssitz."|"Aunque Yamusukro es la capital oficial, Abiyán es la capital de facto."|"Bien que Yamoussoukro soit la capitale officielle, Abidjan est le siège du gouvernement."|"Yamoussoukro er offisiell hovedstad, mens Abidjan er de facto regjeringssete."| | | | | |"<img src=""ug-flag-ivory_coast.svg"" />"|"Ireland (orange and green flipped, wider)"|"Irland (Orange und Grün vertauscht, breiter)"|"Irlanda (naranja y verde intercambiados, más ancha)"|"Irlande (orange et vert inversés, plus large)"|"Ireland (byttet plass på oransje og grønt, bredere)"|"<img src=""ug-map-ivory_coast.png"" />"|"UG::Africa UG::Sovereign_State UG::West_Africa"

  Then there's having too many rows in one csv for it to be properly managed.




  Make changes in your source file and sync those into your Anki collection.

  Make changes inside Anki and pull those back into the source.

  Any user of your shared deck can make a change inside Anki and at some later point export their deck (or just part of it) using CrowdAnki.
  Then the source file can be updated with their changes and a new CrowdAnki Export for all users to import can be generated with one run of Brain Brew.


  Yaml config files are what drive the conversion of Brain Brew, allowing users to easily change the functionality as they wish.

  <!--
  Reusable subconfig files allow for minor changes without breaking the DRY principle.
  -->

  ```Yaml
  - generate_guids_in_csv:
      source: src/data/words.csv
      columns: [ guid ]

  - build_parts:
    - note_model_from_yaml_part:
        part_id: LL Word
        file: src/note_models/LL Word.yaml

    - headers_from_yaml_part:
        part_id: default header
        file: src/headers/default.yaml
        override:  # Optional
          deck_description_html_file: src/headers/desc.html

    - media_group_from_folder:
        part_id: all_media
        source: src/media
        recursive: true  # Optional

    - notes_from_csvs:
        part_id: english-to-danish

        note_model_mappings:
          - note_models:
              - LL Word
            columns_to_fields:  # Optional
              guid: guid
              tags: tags

              english: English
              danish: Word
              picture: Picture
              danish audio: Pronunciation (Recording and/or IPA)

        file_mappings:
          - file: src/data/words.csv
            note_model: LL Word
            sort_by_columns: [english]  # Optional
            reverse_sort: no  # Optional
  ```


  Deck managers can set specific fields to be "Personal", meaning they will not overwrite an existing value on import.

  Working version currently exists, but full PR coming soon to CrowdAnki!


  Free for all to use, modify, or sell this product.

  Further source types are relatively easy to add due to the flexible nature of the backend
  Instead of creating a Csv <-> CrowdAnki converter Brain Brew first goes through a middle layer called "Deck Parts".
  These consist of Notes, Headers, Note Models, and Media files.

  Each new source type to be added to Brain Brew (such as Markdown) need only be able to convert from Deck Parts <-> itself, and suddenly it can convert to and from all existing source types!



  Csvs only update the rows which have changed.
  Meaning a user can import *a subset* of their cards which have changed and still update the source file without deleting the cards they did not include.



  Split data into multiple csvs so that your data is neatly organised however you like.

  The two following csv files contain information about England, but split into different csv files:



  | guid | country | flag | map | tags |
  | ---- | ---- | ---- | ---- | ---- |
  | "e+/O]%*qfk | England | <img src=""ug-flag-england.svg"" /> | <img src=""ug-map-england.png"" /> | UG::Europe |


  | country | capital | capital de | capital es | capital fr | capital nb |
  | ---- | ---- | ---- | ---- | ---- | ---- |
  | England | London | London | Londres | Londres | London |

  Brain Brew can be told that `data-capital` is a derivative of `data-main` in the build config file as such:

  ```yaml
  - file: src/data/data-main.csv               # <---- Main
    note_model: Ultimate Geography
    derivatives:
      - file: src/data/data-country.csv
      - file: src/data/data-country-info.csv
      - file: src/data/data-capital.csv        # <---- Capital
      - file: src/data/data-capital-info.csv
      - file: src/data/data-capital-hint.csv
      
      
      
        
        
      - file: src/data/data-flag-similarity.csv
  ```

  When run Brain Brew will perform the following steps for each derivative:
  1. Finds which columns in the derivative csv match the main (only `country` in this case)
  1. Go through each row in the derivative and find the row with matching values in the main file
  1. Add in the extra columns (`capital` in each language) to that matching row in the main file


  | guid | country | flag | map | tags | capital | capital de | capital es | capital fr | capital nb |
  | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
  | "e+/O]%*qfk | England | <img src=""ug-flag-england.svg"" /> | <img src=""ug-map-england.png"" /> | UG::Europe | London | London | Londres | Londres | London |



  1. **Derivatives can also have derivatives**.

  1. **Csv splitting works in both directions**, to and from csv.

  1. **Derivatives can be given a Note Model**, which overrides their parent's note model for all the matched rows.

  See the [Brain Brew Starter Project][BrainBrewStarter] for an example of Csv Derivatives working.



  [BrainBrewStarter]: https://github.com/ohare93/brain-brew-starter


pkgId: a420a5fabf35afb4083f251cd1f872200fb67ef176a09588e0508b02ec7b3dfa
name: python-BrainStrokeClassifier
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Brain Stroke Classfier using Machine Learning!
url: https://github.com/MUmairAB/BrainStrokeClassifier.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrainStrokeClassifier-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)
  [![Python 3.9](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)

  The package includes a trained Machine Learning model to predict Brain Stroke
  vulnerability. The model can be accessed as **BStClassifier** utility. You can use **BStClassifier(X)** to make predictions. Where **X** is the input consisting of 7 characteristics:
  1. Gender ("Male"=0, "Female"=1, "Other"=-1)
  2. Age
  3. Do you have hypertension (Yes=1/No=0)
  4. Do you have any heart disease (Yes=1/No=0)
  5. What type of work you do? ("Private job"=0, "Self Employed"=1, "Govt. Job"=2, "Never Worked"=-2, "You are a Child"=-1)
  6. Your average blood glucose level
  7. Your Body Mass Index (BMI)

  It classifies whether you are vulnerable to or had brain stroke, or not.


  The input can be:
  1. NumPy array

           a. 1D array of shape (7,)

           b. 2D array of shape (S,7); where S is number of samples
  2. Pandas Series of shape (7,)
  3. Pandas DataFrame of shape (S,7); where S is number of samples

  The Machine Learning model is a Pipeline of Strandard Scaler and XGBoost Classifier. You can check the notebook where the model is trained through the [github](https://github.com/MUmairAB/Stroke-Prediction-using-Machine-Learning/blob/a0c9126b4f8c55ea528b1f60354f441148173567/stroke-prediction.ipynb)


  Make sure you have Python installed in your system.
  Run Following command in the command window.
   ```
    !pip install BrainStrokeClassifier
    ```


   ```




  !pip install BrainStrokeClassifier


  from BrainStrokeClassifier import BStClassifier
  import numpy as np
  import pandas as pd



  x = np.array([[0,67,0,1,0,228.69,36.6],
                [0,58,1,0,0,87.96,39.2]])

  df = pd.DataFrame(x)
  prediction = BStClassifier(df)
  print(prediction)
   ```

  **If you have any suggestions or improvements, please fork the package on [github](https://github.com/MUmairAB/BrainStrokeClassifier/issues)**


  **The Umair Akram | MUmairAB**


pkgId: 4eba27a888bf865466b433b4f9328bb10778ebfbec049b507a9c491099e12cdc
name: python-BrazilFiscalReport
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Python library for generating Brazilian auxiliary fiscal documents in PDF from XML documents.
url: https://pypi.org/project/BrazilFiscalReport/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrazilFiscalReport-0.4.3-1.src.rpm
checksum_type: sha256
description:
  [![image](https://github.com/engenere/BrazilFiscalReport/workflows/tests/badge.svg)](https://github.com/Engenere/BrazilFiscalReport/actions)
  [![image](https://codecov.io/gh/engenere/BrazilFiscalReport/branch/main/graph/badge.svg)](https://app.codecov.io/gh/Engenere/BrazilFiscalReport)
  [![image](https://img.shields.io/github/languages/top/Engenere/brazilfiscalreport)](https://pypi.org/project/BrazilFiscalReport/)
  [![image](https://img.shields.io/pypi/v/brazilfiscalreport.svg)](https://pypi.org/project/BrazilFiscalReport/)
  [![image](https://img.shields.io/pypi/l/brazilfiscalreport)](https://github.com/Engenere/BrazilFiscalReport/blob/main/LICENSE)
  ![beta](https://img.shields.io/badge/status-beta-orange)


  Python library for generating Brazilian auxiliary fiscal documents in PDF from XML documents.



  - DANFE - Documento Auxiliar da Nota Fiscal Eletrônica (NF-e)
  - DACCe - Documento Auxiliar da Carta de Correção Eletrônica (CC-e )



  This library is currently in the beta stage of development. While it has many of the intended features implemented, it is still undergoing testing and improvements. Users should note that during this phase, functionality may change and some instability may occur. We welcome feedback on any issues or suggestions for enhancements. Use in production environments should be approached with caution.



  - [FPDF2](https://github.com/py-pdf/fpdf2) - PDF creation library for Python
  - phonenumbers
  - python-barcode



  ```bash
  pip install brazilfiscalreport
  ```




  ```python
  from brazilfiscalreport.danfe import Danfe


  xml_file_path = 'nfe.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  danfe = Danfe(xml=xml_content)


  danfe.output('danfe.pdf')
  ```


  ```python
  from brazilfiscalreport.dacce import DaCCe


  xml_file_path = 'cce.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  cce = DaCCe(xml=xml_content)


  cce.output('cce.pdf')
  ```



  Some sample PDFs generated by our unit tests are available for viewing in the [tests/generated](https://github.com/Engenere/BrazilFiscalReport/tree/main/tests/generated) directory.



  This section describes how to customize the PDF output of the DANFE using the ``DanfeConfig`` class. You can adjust various settings such as margins, fonts, and tax configurations according to your needs.



  Here is a breakdown of all the configuration options available in ``DanfeConfig``:

  1. **Logo**
     - **Type**: ``str``, ``BytesIO``, or ``bytes``
     - **Description**: Path to the logo file or binary image data to be included in the PDF. You can use a file path string or pass image data directly.
     - **Example**:
          ```python
         config.logo = "path/to/logo.jpg"  # Using a file path
        ```
     - **Default**: No logo.


  2. **Margins**
     - **Type**: ``Margins``
     - **Fields**: ``top``, ``right``, ``bottom``, ``left`` (all of type ``Number``)
     - **Description**: Sets the page margins for the PDF document.
     - **Example**:
          ```python
          config.margins = Margins(top=5, right=5, bottom=5, left=5)
          ```
     - **Default**: top, right, bottom and left is 2 mm.

  3. **Receipt Position**
     - **Type**: ``ReceiptPosition`` (Enum)
     - **Values**: ``TOP``, ``BOTTOM``, ``LEFT``
     - **Description**: Position of the receipt section in the DANFE.
     - **Example**:
          ```python
          config.receipt_pos = ReceiptPosition.BOTTOM
          ```
     - **Default**: ``TOP`` when portrait, ``LEFT`` when landscape orientation.
     - **Note**: In landscape orientation, the receipt position is far left; customization is not permitted.

  4. **Decimal Configuration**
     - **Type**: ``DecimalConfig``
     - **Fields**: ``price_precision``, ``quantity_precision`` (both ``int``)
     - **Description**: Defines the number of decimal places for prices and quantities.
     - **Example**:
          ```python
         config.decimal_config = DecimalConfig(price_precision=2, quantity_precision=3)
          ```
     - **Default**: 4

  5. **Tax Configuration**
     - **Type**: ``TaxConfiguration`` (Enum)
     - **Values**: ``STANDARD_ICMS_IPI``, ``ICMS_ST_ONLY``, ``WITHOUT_IPI``
     - **Description**: Specifies the tax fields to be displayed.
     - **Example**:
          ```python
          config.tax_configuration = TaxConfiguration.WITHOUT_IPI
          ```
     - **Default**: ``STANDARD_ICMS_IPI``
     - **WARNING: This feature is not yet implemented.**

  6. **Invoice Display**
     - **Type**: ``InvoiceDisplay`` (Enum)
     - **Values**: ``DUPLICATES_ONLY``, ``FULL_DETAILS``
     - **Description**: Controls the detail level in the invoice section of the DANFE.
     - **Example**::
          ```python
         config.invoice_display = InvoiceDisplay.DUPLICATES_ONLY
          ```
     - **Default**: ``FULL_DETAILS``

  7. **Font Type**
     - **Type**: ``FontType`` (Enum)
     - **Values**: ``COURIER``, ``TIMES``
     - **Description**: Font style used throughout the PDF document.
     - **Example**::
          ```python
         config.font_type = FontType.COURIER
          ```
     - **Default**: ``TIMES``

  8. **Display PIS COFINS**
     - **Type**: ``Bool``
     - **Values**: ``True``, ``False``
     - **Description**: Displays PIS and COFINS taxes in the DANFE totals.
     - **Example**::
          ```python
         config.display_pis_cofins = True
          ```
     - **Default**: ``False``


  Here’s how to set up a ``DanfeConfig`` object with a full set of customizations::

  ```python
  from brazilfiscalreport.danfe import (
      Danfe,
      DanfeConfig,
      DecimalConfig,
      FontType,
      InvoiceDisplay,
      Margins,
      ReceiptPosition,
      TaxConfiguration,
  )


  xml_file_path = 'nfe.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  config = DanfeConfig(
      logo='path/to/logo.png',
      margins=Margins(top=10, right=10, bottom=10, left=10),
      receipt_pos=ReceiptPosition.BOTTOM,
      decimal_config=DecimalConfig(price_precision=2, quantity_precision=2),
      tax_configuration=TaxConfiguration.ICMS_ST,
      invoice_display=InvoiceDisplay.FULL_DETAILS,
      font_type=FontType.TIMES
  )


  danfe = Danfe(xml_content, config=config)
  danfe.output('output_danfe.pdf')
  ```


  This is a fork of the [nfe_utils](https://github.com/edsonbernar/nfe_utils) project, originally created by [Edson Bernardino](https://github.com/edsonbernar).


  [![Engenere](https://storage.googleapis.com/eng-imagens/logo-fundo-preto.webp)]([#](https://engenere.one/))

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.   This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.  0. Additional Definitions.  As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License.  "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.  An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.  A "Combined Work" is a work produced by combining or linking an Application with the Library.  The particular version of the Library with which the Combined Work was made is also called the "Linked Version".  The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.  The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.  1. Exception to Section 3 of the GNU GPL.  You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.  2. Conveying Modified Versions.  If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:  a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or  b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.  3. Object Code Incorporating Material from Library Header Files.  The object code form of an Application may incorporate material from a header file that is part of the Library.  You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:  a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the object code with a copy of the GNU GPL and this license document.  4. Combined Works.  You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:  a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the Combined Work with a copy of the GNU GPL and this license document.  c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.  d) Do one of the following:  0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.  1) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.  e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)  5. Combined Libraries.  You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.  b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  6. Revised Versions of the GNU Lesser General Public License.  The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.  If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.


pkgId: 154f7d1cf8ac5d4eff5fb806d3ba0a76851e4207de97ee842c5fc41330000b8e
name: python-BrazilFiscalReport
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Python library for generating Brazilian auxiliary fiscal documents in PDF from XML documents.
url: https://pypi.org/project/BrazilFiscalReport/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrazilFiscalReport-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![image](https://github.com/engenere/BrazilFiscalReport/workflows/tests/badge.svg)](https://github.com/Engenere/BrazilFiscalReport/actions)
  [![image](https://codecov.io/gh/engenere/BrazilFiscalReport/branch/main/graph/badge.svg)](https://app.codecov.io/gh/Engenere/BrazilFiscalReport)
  [![image](https://img.shields.io/github/languages/top/Engenere/brazilfiscalreport)](https://pypi.org/project/BrazilFiscalReport/)
  [![image](https://img.shields.io/pypi/v/brazilfiscalreport.svg)](https://pypi.org/project/BrazilFiscalReport/)
  [![image](https://img.shields.io/pypi/l/brazilfiscalreport)](https://github.com/Engenere/BrazilFiscalReport/blob/main/LICENSE)
  ![beta](https://img.shields.io/badge/status-beta-orange)


  Python library for generating Brazilian auxiliary fiscal documents in PDF from XML documents.



  - DANFE - Documento Auxiliar da Nota Fiscal Eletrônica (NF-e)
  - DACCe - Documento Auxiliar da Carta de Correção Eletrônica (CC-e )
  - DACTE - Documento Auxiliar do Conhecimento de Transporte Eletrônico (CT-e)
  - DAMDFE - Documento Auxiliar do Manifesto Eletrônico de Documentos Fiscais (MDF-e)



  This library is currently in the beta stage of development. While it has many of the intended features implemented, it is still undergoing testing and improvements. Users should note that during this phase, functionality may change and some instability may occur. We welcome feedback on any issues or suggestions for enhancements. Use in production environments should be approached with caution.



  - [FPDF2](https://github.com/py-pdf/fpdf2) - PDF creation library for Python
  - phonenumbers
  - python-barcode
  - qrcode (only required for DACTE)



  ```bash
  pip install brazilfiscalreport
  ```


  If you specifically need the DACTE functionality, you can install it along with its required dependencies using:

  ```bash
  pip install brazilfiscalreport[dacte]
  ```




  ```python
  from brazilfiscalreport.danfe import Danfe


  xml_file_path = 'nfe.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  danfe = Danfe(xml=xml_content)


  danfe.output('danfe.pdf')
  ```


  ```python
  from brazilfiscalreport.dacce import DaCCe


  xml_file_path = 'cce.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  cce = DaCCe(xml=xml_content)


  cce.output('cce.pdf')
  ```



  ```python
  from brazilfiscalreport.dacte import Dacte


  xml_file_path = 'dacte.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  dacte = Dacte(xml=xml_content)


  dacte.output('dacte.pdf')
  ```



  ```python
  from brazilfiscalreport.damdfe import Damdfe


  xml_file_path = 'damdfe.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  damdfe = Damdfe(xml=xml_content)


  damdfe.output('damdfe.pdf')
  ```



  Some sample PDFs generated by our unit tests are available for viewing in the [tests/generated](https://github.com/Engenere/BrazilFiscalReport/tree/main/tests/generated) directory.



  This section describes how to customize the PDF output of the DANFE using the ``DanfeConfig`` class. You can adjust various settings such as margins, fonts, and tax configurations according to your needs.



  Here is a breakdown of all the configuration options available in ``DanfeConfig``:

  1. **Logo**
     - **Type**: ``str``, ``BytesIO``, or ``bytes``
     - **Description**: Path to the logo file or binary image data to be included in the PDF. You can use a file path string or pass image data directly.
     - **Example**:
          ```python
         config.logo = "path/to/logo.jpg"  # Using a file path
        ```
     - **Default**: No logo.


  2. **Margins**
     - **Type**: ``Margins``
     - **Fields**: ``top``, ``right``, ``bottom``, ``left`` (all of type ``Number``)
     - **Description**: Sets the page margins for the PDF document.
     - **Example**:
          ```python
          config.margins = Margins(top=5, right=5, bottom=5, left=5)
          ```
     - **Default**: top, right, bottom and left is 5 mm.

  3. **Receipt Position**
     - **Type**: ``ReceiptPosition`` (Enum)
     - **Values**: ``TOP``, ``BOTTOM``, ``LEFT``
     - **Description**: Position of the receipt section in the DANFE.
     - **Example**:
          ```python
          config.receipt_pos = ReceiptPosition.BOTTOM
          ```
     - **Default**: ``TOP`` when portrait, ``LEFT`` when landscape orientation.
     - **Note**: In landscape orientation, the receipt position is far left; customization is not permitted.

  4. **Decimal Configuration**
     - **Type**: ``DecimalConfig``
     - **Fields**: ``price_precision``, ``quantity_precision`` (both ``int``)
     - **Description**: Defines the number of decimal places for prices and quantities.
     - **Example**:
          ```python
         config.decimal_config = DecimalConfig(price_precision=2, quantity_precision=3)
          ```
     - **Default**: 4

  5. **Tax Configuration**
     - **Type**: ``TaxConfiguration`` (Enum)
     - **Values**: ``STANDARD_ICMS_IPI``, ``ICMS_ST_ONLY``, ``WITHOUT_IPI``
     - **Description**: Specifies the tax fields to be displayed.
     - **Example**:
          ```python
          config.tax_configuration = TaxConfiguration.WITHOUT_IPI
          ```
     - **Default**: ``STANDARD_ICMS_IPI``
     - **WARNING: This feature is not yet implemented.**

  6. **Invoice Display**
     - **Type**: ``InvoiceDisplay`` (Enum)
     - **Values**: ``DUPLICATES_ONLY``, ``FULL_DETAILS``
     - **Description**: Controls the detail level in the invoice section of the DANFE.
     - **Example**::
          ```python
         config.invoice_display = InvoiceDisplay.DUPLICATES_ONLY
          ```
     - **Default**: ``FULL_DETAILS``

  7. **Font Type**
     - **Type**: ``FontType`` (Enum)
     - **Values**: ``COURIER``, ``TIMES``
     - **Description**: Font style used throughout the PDF document.
     - **Example**::
          ```python
         config.font_type = FontType.COURIER
          ```
     - **Default**: ``TIMES``

  8. **Display PIS COFINS**
     - **Type**: ``Bool``
     - **Values**: ``True``, ``False``
     - **Description**: Displays PIS and COFINS taxes in the DANFE totals.
     - **Example**::
          ```python
         config.display_pis_cofins = True
          ```
     - **Default**: ``False``


  Here’s how to set up a ``DanfeConfig`` object with a full set of customizations::

  ```python
  from brazilfiscalreport.danfe import (
      Danfe,
      DanfeConfig,
      DecimalConfig,
      FontType,
      InvoiceDisplay,
      Margins,
      ReceiptPosition,
      TaxConfiguration,
  )


  xml_file_path = 'nfe.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  config = DanfeConfig(
      logo='path/to/logo.png',
      margins=Margins(top=10, right=10, bottom=10, left=10),
      receipt_pos=ReceiptPosition.BOTTOM,
      decimal_config=DecimalConfig(price_precision=2, quantity_precision=2),
      tax_configuration=TaxConfiguration.ICMS_ST,
      invoice_display=InvoiceDisplay.FULL_DETAILS,
      font_type=FontType.TIMES
  )


  danfe = Danfe(xml_content, config=config)
  danfe.output('output_danfe.pdf')
  ```



  This section describes how to customize the PDF output of the DACTE using the DacteConfig class. You can adjust various settings such as margins, fonts, and tax configurations according to your needs.



  Here is a breakdown of all the configuration options available in ``DanfeConfig``:

  1. **Logo**
     - **Type**: ``str``, ``BytesIO``, or ``bytes``
     - **Description**: Path to the logo file or binary image data to be included in the PDF. You can use a file path string or pass image data directly.
     - **Example**:
          ```python
         config.logo = "path/to/logo.jpg"  # Using a file path
        ```
     - **Default**: No logo.


  2. **Margins**
     - **Type**: ``Margins``
     - **Fields**: ``top``, ``right``, ``bottom``, ``left`` (all of type ``Number``)
     - **Description**: Sets the page margins for the PDF document.
     - **Example**:
          ```python
          config.margins = Margins(top=5, right=5, bottom=5, left=5)
          ```
     - **Default**: top, right, bottom and left is 5 mm.

  3. **Font Type**
     - **Type**: ``FontType`` (Enum)
     - **Values**: ``COURIER``, ``TIMES``
     - **Description**: Font style used throughout the PDF document.
     - **Example**::
          ```python
         config.font_type = FontType.COURIER
          ```
     - **Default**: ``TIMES``



  Here’s how to set up a DacteConfig object with a full set of customizations:

  ```python
  from brazilfiscalreport.dacte import (
      Dacte,
      DacteConfig,
      FontType,
      Margins,
  )


  xml_file_path = 'cte.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  config = DacteConfig(
      logo='path/to/logo.png',
      margins=Margins(top=10, right=10, bottom=10, left=10),
      font_type=FontType.TIMES
  )


  dacte = Dacte(xml_content, config=config)
  dacte.output('output_dacte.pdf')
  ```



  This section describes how to customize the PDF output of the DAMDFE using the DamdfeConfig class. You can adjust various settings such as margins, fonts, and tax configurations according to your needs.



  Here is a breakdown of all the configuration options available in ``DamdfeConfig``:

  1. **Logo**
     - **Type**: ``str``, ``BytesIO``, or ``bytes``
     - **Description**: Path to the logo file or binary image data to be included in the PDF. You can use a file path string or pass image data directly.
     - **Example**:
          ```python
         config.logo = "path/to/logo.jpg"  # Using a file path
        ```
     - **Default**: No logo.


  2. **Margins**
     - **Type**: ``Margins``
     - **Fields**: ``top``, ``right``, ``bottom``, ``left`` (all of type ``Number``)
     - **Description**: Sets the page margins for the PDF document.
     - **Example**:
          ```python
          config.margins = Margins(top=10, right=10, bottom=10, left=10)
          ```
     - **Default**: top, right, bottom and left is 5 mm.

  3. **Font Type**
     - **Type**: ``FontType`` (Enum)
     - **Values**: ``COURIER``, ``TIMES``
     - **Description**: Font style used throughout the PDF document.
     - **Example**::
          ```python
         config.font_type = FontType.COURIER
          ```
     - **Default**: ``TIMES``



  Here’s how to set up a DamdfeConfig object with a full set of customizations:

  ```python
  from brazilfiscalreport.damdfe import (
      Damdfe,
      DacteConfig,
      FontType,
      Margins,
  )


  xml_file_path = 'mdf-e.xml'


  with open(xml_file_path, "r", encoding="utf8") as file:
      xml_content = file.read()


  config = DamdfeConfig(
      logo='path/to/logo.png',
      margins=Margins(top=10, right=10, bottom=10, left=10),
      font_type=FontType.TIMES
  )


  damdfe = Damdfe(xml_content, config=config)
  damdfe.output('output_dacte.pdf')
  ```


  This is a fork of the [nfe_utils](https://github.com/edsonbernar/nfe_utils) project, originally created by [Edson Bernardino](https://github.com/edsonbernar).


  [![Engenere](https://storage.googleapis.com/eng-imagens/logo-fundo-preto.webp)]([#](https://engenere.one/))

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.   This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.  0. Additional Definitions.  As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License.  "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.  An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.  A "Combined Work" is a work produced by combining or linking an Application with the Library.  The particular version of the Library with which the Combined Work was made is also called the "Linked Version".  The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.  The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.  1. Exception to Section 3 of the GNU GPL.  You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.  2. Conveying Modified Versions.  If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:  a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or  b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.  3. Object Code Incorporating Material from Library Header Files.  The object code form of an Application may incorporate material from a header file that is part of the Library.  You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:  a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the object code with a copy of the GNU GPL and this license document.  4. Combined Works.  You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:  a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the Combined Work with a copy of the GNU GPL and this license document.  c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.  d) Do one of the following:  0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.  1) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.  e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)  5. Combined Libraries.  You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.  b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  6. Revised Versions of the GNU Lesser General Public License.  The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.  If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.


pkgId: 1fe6f67275ed215db9b1445914f0ee77bb5f03829d12a447235b2fb2cb8d6750
name: python-BrazilFiscalReport
arch: src
version: 0.5.8
epoch: 0
release: 1
summary: Python library for generating Brazilian auxiliary fiscal documents in PDF from XML documents.
url: https://pypi.org/project/BrazilFiscalReport/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrazilFiscalReport-0.5.8-1.src.rpm
checksum_type: sha256
description:
  [![image](https://github.com/engenere/BrazilFiscalReport/workflows/tests/badge.svg)](https://github.com/Engenere/BrazilFiscalReport/actions)
  [![image](https://codecov.io/gh/engenere/BrazilFiscalReport/branch/main/graph/badge.svg)](https://app.codecov.io/gh/Engenere/BrazilFiscalReport)
  [![image](https://img.shields.io/github/languages/top/Engenere/brazilfiscalreport)](https://pypi.org/project/BrazilFiscalReport/)
  [![image](https://img.shields.io/pypi/v/brazilfiscalreport.svg)](https://pypi.org/project/BrazilFiscalReport/)
  [![image](https://img.shields.io/pypi/l/brazilfiscalreport)](https://github.com/Engenere/BrazilFiscalReport/blob/main/LICENSE)
  ![beta](https://img.shields.io/badge/status-beta-orange)


  Python library for generating Brazilian auxiliary fiscal documents in PDF from XML documents.



  - **DANFE** - Documento Auxiliar da Nota Fiscal Eletrônica (NF-e)
  - **DACCe** - Documento Auxiliar da Carta de Correção Eletrônica (CC-e)
  - **DACTE** - Documento Auxiliar do Conhecimento de Transporte Eletrônico (CT-e)
  - **DAMDFE** - Documento Auxiliar do Manifesto Eletrônico de Documentos Fiscais (MDF-e)



  This library is currently in the beta stage of development. While it has many of the intended features implemented, it is still undergoing testing and improvements. Users should note that during this phase, functionality may change and some instability may occur. We welcome feedback on any issues or suggestions for enhancements. Use in production environments should be approached with caution.

  Check the [documentation](https://engenere.github.io/BrazilFiscalReport/) for more ✨✨✨



  - [FPDF2](https://github.com/py-pdf/fpdf2) - PDF creation library for Python
  - phonenumbers
  - python-barcode
  - qrcode (only required for DACTE)



  ```bash
  pip install brazilfiscalreport
  ```


  If you specifically need the DACTE functionality, you can install it along with its required dependencies using:

  ```bash
  pip install brazilfiscalreport[dacte]
  ```


  If you specifically need the CLI functionality, you can install it along with its required dependencies using:

  ```bash
  pip install brazilfiscalreport[cli]
  ```


  This is a fork of the [nfe_utils](https://github.com/edsonbernar/nfe_utils) project, originally created by [Edson Bernardino](https://github.com/edsonbernar).


  [![Engenere](https://storage.googleapis.com/eng-imagens/logo-fundo-preto.webp)]([#](https://engenere.one/))

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


pkgId: 02e8dd922759f7ca6e4b122852e4d540b4f6f9aa2dd5d9834f28543f3c209725
name: python-Brevia
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/brevia-ai/brevia
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Brevia-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  Extensible API and framework to build your Retrieval Augmented Generation (RAG) and Information Extraction (IE) applications with LLMs

description:
  [![Github Actions CS](https://github.com/brevia-ai/brevia/actions/workflows/cs.yml/badge.svg)](https://github.com/brevia-ai/brevia/actions?query=workflow%3Acs)
  [![Github Actions Unit](https://github.com/brevia-ai/brevia/actions/workflows/unit.yml/badge.svg)](https://github.com/brevia-ai/brevia/actions?query=workflow%3Aunit)
  [![Coverage Status](https://coveralls.io/repos/github/brevia-ai/brevia/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/brevia-ai/brevia?branch=main)
  ![Python Versions](https://img.shields.io/pypi/pyversions/brevia.svg)
  [![Version](https://img.shields.io/pypi/v/brevia.svg?label=brevia)](https://pypi.org/project/brevia/)
  [![License](https://img.shields.io/badge/license-MIT-orange.svg)](https://github.com/brevia-ai/brevia/blob/main/LICENSE)

  Brevia is an extensible API and framework to build your Retrieval Augmented Generation (RAG) and Information Extraction (IE) applications with LLMs.

  Ouf of the box Brevia provides:

  * a complete API for RAG applications
  * an API with Information extractions capabilities like summarization, with the possibility to create your own analysis logic with asycnhronous background operations support

  Brevia uses:

  * the popular [LangChain](https://github.com/langchain-ai/langchain) framework that you can use to create your custom AI tools and logic
  * the [FastAPI](https://github.com/tiangolo/fastapi) framework to easily extend your application with new endpoints
  * [PostgreSQL](https://www.postgresql.org) with [`pg_vector`](https://github.com/pgvector/pgvector) extension as vector database



  Brevia documentation is available at [docs.brevia.app](https://docs.brevia.app).



  An official UI is now available via [Brevia App](https://github.com/brevia-ai/brevia-app).
  It is a webapp with which you can:

  * create and configure new RAG collections
  * add files, questions or links to each collection
  * test the collection with a chat UI
  * analyze the chat history for each collection
  * perform some Information Extraction actions like summarization, audio transcription or custom analysis



  A version of Python 3.10 or higher and [Poetry](https://python-poetry.org/docs/#installation) is required.
  A PostgreSQL database version 14 or higher with [`pg_vector`](https://github.com/pgvector/pgvector), but you can use the provided docker image for a quicker setup.



  The easiest and fastest way to try Brevia is through Docker. By launching docker compose with the following command you will have a working Brevia system without any setup or configuration:

  ```bash
  docker compose --profile fullstack up
  ```

  At this point you will have:

  * Brevia API on http://localhost:8000
  * Brevia App UI on http://localhost:3000

  To use ports other than 8000 or 3000 just uncomment the variables `BREVIA_API_PORT` or `BREVIA_APP_PORT` in the .env file.

  You can also use `--profile api` option to just start Brevia API and not Brevia App.





  The quickest way to create a new Brevia project is using the [cookiecutter](https://github.com/cookiecutter/cookiecutter) template project like this:

  ```bash
  pip install cookiecutter
  cookiecutter gh:brevia-ai/brevia-cookiecutter
  ```

  Simply answer few simple questions and you're ready to go.



  To manually create a project instead follow these steps:

  * create a new project with `poetry new {your-brevia-project}`
  * install brevia and its dependencies by running `poetry add brevia`, a virtualenv will automatically be created
  * create a new `main.py` starting with a [copy](https://raw.githubusercontent.com/brevia-ai/brevia-cookiecutter/main/%7B%7Bcookiecutter.project_slug%7D%7D/main.py)
  * activate the virtualenv by running the `poetry shell` command
  * copy the file `.env.sample` to `.env` and value the environment variables, especially `OPENAI_API_KEY` with the secret key of OpenAI and `PGVECTOR_*` see the [Database](#database) section



  In addition to using the default OpenAI models, you have the option to integrate other Large Language Models, such as the Cohere model or any other model of your choice. Follow the steps below to set up and use a custom model in your Brevia project.



  Once you have the Cohere API key and model name, update your Brevia project to include these credentials.

  0. Prerequisites: install cohere lib:

      ```bash
      poetry add cohere
      ```

  1. Open the `.env` file in your project directory.

  2. Set the `COHERE_API_KEY` variable with your Cohere API key:

      ```bash
      COHERE_API_KEY=your-cohere-api-key
      ```

  3. Set the cohere variables with the desired Cohere parameter:

  For QA/RAG application, set in `QA_COMPLETION_LLM` and `QA_FOLLOWUP_LLM` the json as follow:

      ```bash
      QA_COMPLETION_LLM='{
          "_type": "cohere-chat",
          "model_name": "command",
          "temperature": 0,
          "max_tokens": 200,
          "verbose": true
      }'

      QA_FOLLOWUP_LLM='{
          "_type": "cohere-chat",
          "model_name": "command",
          "temperature": 0,
          "max_tokens": 200,
          "verbose": true
      }'
      ```

  With relatives embeddings:

      ```bash
      EMBEDDINGS='{
          "_type": "cohere-embeddings"
      }'
      ```

  4. For Summarization module, set  the `SUMMARIZE_LLM` var:

      ```bash
      SUMMARIZE_LLM='{
          "_type": "cohere-chat",
          "model_name": "command",
          "temperature": 0,
          "max_tokens": 2000
      }'
      ```



  If you have a PostgreSQL instance with `pg_vector` extension available you are ready to go, otherwise you can use the provided docker compose file.

  In this case you can simply run `docker compose` to run a PostgreSQL database with pg_vector.
  You can also run the embedded [`pgAdmin`](https://www.pgadmin.org) admin tool running `docker compose --profile admin up` to run postgres+pgvector and pgadmin docker images at the same time.
  With your browser, open `pgadmin` at http://localhost:4000

  The `4000` port is configurable with the `PGADMIN_PORT` environment var in the `.env` file.



  Before using Brevia you need to launch the migrations script in order to create or update the initial schema. This is done with [Alembic](https://alembic.sqlalchemy.org) by using this command

  ```bash
  db_upgrade
  ```



  You are now ready to go, simply run

  ```bash
  uvicorn --env-file .env main:app`
  ```

  and your [Brevia API](https://github.com/brevia-ai/brevia) project is ready to accept calls!



  While we are working on a simple reference frontend to test and use Brevia API the simplest way to test your new API is by using the provided OpenAPI Swagger UI and ReDoc UI or by using the official Postman files.

  Simply point to `/docs` for your Swagger UI and to `/redoc` for ReDoc.

  If you prefer to use Postman you can start by importing the [collection file](https://raw.githubusercontent.com/brevia-ai/brevia/main/brevia/postman/Brevia%20API.postman_collection.json) and an [environment sample](https://raw.githubusercontent.com/brevia-ai/brevia/main/brevia/postman/Brevia%20API.postman_environment.json)



  You can also quickly create collections and add documents via CLI using the `import_file` command.

  Just run:

  ```bash
  import_file --file-path /path/to/file --collection my-collection
  ```

  Where

  * `/path/to/file` is the path to a local PDF or txt file
  * `my-collection` is the unique name of the collection that will be created if not exists



  To import/export collections via CLI we take advantage of the [PostgreSQL COPY command](https://www.postgresql.org/docs/current/sql-copy.html) in the `import_collection` and `export_collection` scripts.

  A `psql` client is required for these scripts, connection parameters will be read from environment variables (via `.env` file).

  Two PostgreSQL CSV files will be created during export and imported in the import operation.
  One file, named `{collection-name}-collection.csv`, contains collection data and the other, named `{collection-name}-embedding.csv`, contains documents data and embeddings.

  To export a collection use:

  ```bash
  export_collection --folder-path /path/to/folder --collection collection-name
  ```

  To import a collection use:

  ```bash
  import_collection --folder-path /path/to/folder --collection collection-name
  ```

  Where

  * `/path/to/folder` is the path where the 2 CSV files will be created in export or searched in import
  * `collection-name` is the name of the collection



  [LangSmith](https://www.langchain.com/langsmith) is a platform to monitor, test and debug LLM apps built with LangChain.
  To use it in Brevia, if you have an account, you should export these environment variables when runnnin Brevia:

  ```bash
  LANGCHAIN_TRACING_V2=True
  LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"
  LANGCHAIN_API_KEY="########"
  LANGCHAIN_PROJECT="My Project"
  ```

  If you are using a `.env` file you should use `BREVIA_ENV_SECRETS` var like this:

  ```bash

  BREVIA_ENV_SECRETS='{
    "LANGCHAIN_TRACING_V2": "True"
    "LANGCHAIN_ENDPOINT": "https://api.smith.langchain.com",
    "LANGCHAIN_API_KEY": "########",
    "LANGCHAIN_PROJECT": "My Project"
  }'
  ```

  This way Brevia will make sure that this variables will be available as environment variables.

  Edit `LANGCHAIN_API_KEY` with your LangSmith API Key and set your project name in `LANGCHAIN_PROJECT` var.



  There is a built-in basic support for access tokens for API security.

  Access tokens are actively checked via `Authoritazion: Bearer <token>` header if a `TOKENS_SECRET` env variable has been set.
  You may then generate a new access token using:

  ```bash
  poetry run create_token --user {user} --duration {minutes}
  ```

  If the env `TOKENS_SECRET` variable is set token verification is automatically performed on every endpoint using `brevia.dependencies.get_dependencies` in its dependencies.

  The recommended way yo generate `TOKENS_SECRET` is by using openssl via cli like

  ```bash
  openssl rand -hex 32
  ```

  You can also define a list of valid users as a comma separated string in the `TOKENS_USERS` env variable.

  Setting it like `TOKENS_USERS="brevia,gustavo"` means that only `brevia` and `gustavo` are considered valid users names. Remember to use double quotes in a `.env` file.



  Here some brief notes if you want to help develop Brevia.



  To launch unit tests make sure to have `dev` dependencies installed. This is done with:

  ```bash
  poetry install --with dev
  ```

  A `tests/.env` file must be present where test environment variables are set, you can start with a copy of `tests/.env.sample`.
  Please make sure that `PGVECTOR_*` variables point to a unit test database that will be continuously dropped and recreated. Also make sure to set `USE_TEST_MODELS=True` in order to use fake LLM instances.

  To launch unit tests, type from virtualenv:

  ```bash
  pytest tests/
  ```

  To create coverage in HTML format:

  ```bash
  pytest --cov-report html --cov=brevia tests/
  ```

  Covreage report is created using `pytest-cov`



  Install `mkdocs-material` using `pip` without altering `pyproject.toml`

  ```bash
  pip install mkdocs-material
  ```

  When working on documentation files you can use a live preview server with:

  ```bash
  mkdocs serve
  ```

  Or you can build the documentation in `site/` folder using

  ```bash
  mkdocs build --clean
  ```


pkgId: 17cf11b346137306ae28668e42affc4990403dda21da35e4469983751a97a394
name: python-Brian2GeNN
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: An interface to use the GeNN framework as a device in Brian 2
url: https://pypi.org/project/Brian2GeNN/
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Brian2GeNN-1.7.0-1.src.rpm
checksum_type: sha256
description:
  Brian2GeNN is an interface between Brian 2 and GeNN. Brian2 is a simulator for spiking neural networks available on a variety of platforms. It is the successor of Brian1 and shares its approach of being highly flexible and easily extensible. It is based on a code generation framework that allows to execute simulations using other programming languages and/or on different
  devices.
  GeNN (GPU enhanced Neuronal Networks, https://github.com/genn-team/genn) is a framework that uses code generation methods to allow using GPU accelerators without in-depth knowledge of the CUDA programming interface.
  Brian2Genn provides an interface to use GeNN as a backend device in Brian2. This allows users to run their Brian 2 scripts on NVIDIA GPU accelerators without any further necessary programming.
  We currently consider this software to be in the beta status, please report
  issues to the github issue tracker (https://github.com/brian-team/brian2genn/issues).
  Documentation for Brian2GeNN can be found at http://brian2genn.readthedocs.org
  [![PyPI package](https://img.shields.io/pypi/v/Brian2GeNN.svg)](https://pypi.python.org/pypi/Brian2GeNN)
  [![Documentation Status](https://readthedocs.org/projects/brian2genn/badge/?version=stable)](https://brian2genn.readthedocs.io/en/stable/?badge=stable)
  [![Build Status](https://github.com/brian-team/brian2genn/actions/workflows/testsuite.yml/badge.svg)](https://github.com/brian-team/brian2genn/actions/workflows/testsuite.yml)
  If you use BrianGeNN for your published research, we kindly ask you to cite our article:
  Marcel Stimberg, Dan F. M. Goodman, and Thomas Nowotny. “Brian2GeNN: Accelerating Spiking Neural Network Simulations with Graphics Hardware.” Sci Rep 10 (January 2020): 410. [doi: 10.1038/s41598-019-54957-7](https://doi.org/10.1038/s41598-019-54957-7).


pkgId: d53975b639c753f54f3beb460bb3da2439c4f0a17e5f86376230f5b639e3db22
name: python-BrickBreakerGame
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Brick Breaker game
url: https://github.com/Urosh91/BrickBreaker
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrickBreakerGame-0.2.6-1.src.rpm
checksum_type: sha256
description:
  Brick Breaker is a simple game based on breaking bricks
  and progressing through levels.
  You can get it by downloading it directly or by typing:
      $ pip install BrickBreakerGame
  After it is installed you can start it by simply typing in your terminal:
      $ brickbreaker


pkgId: 8b09c7f3e962eec5f242a32a83ece88608640e64e8ad19293e076ae78d0888e7
name: python-BrickBundles
arch: src
version: 0.13.3
epoch: 0
release: 1
summary: Brick Bundles package, i.e. all Brick sourcefiles and convenience access method in a package
url: https://pypi.org/project/BrickBundles/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrickBundles-0.13.3-1.src.rpm
checksum_type: sha256
description:
  Contains all BRICK bundles such as Physics, Robotics, DriveTrain and Simulation.
  The package contains convenience methods and .brick files.



  ```bash
  pip install brickbundles
  ```



  [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)



  ```python
  from brickbundles import bundle_path
  assert os.path.exists(f"{bundle_path()}/Simulation/config.brick")
  ```


pkgId: a28446c95ddbd33a023b22b41b6c298906f5689849a39cea9eb2bae06fc9fc60
name: python-BrickFTP
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Python Client for BrickFTP API (https://developers.brickftp.com/).
url: https://github.com/Usio-Energy/BrickFTP
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrickFTP-0.5.1-1.src.rpm
checksum_type: sha256
description:
  |PyPI| |Python Versions| |Build Status|
  Python Client for BrickFTP API (https://developers.brickftp.com/).
  This client does not implement all the features of the API, pull requests are very welcome to expand functionality.


pkgId: 61b0aa7dea68610f24d9c2e1a46477e1022fec0ffc9362cb3c9f16bd95f66985
name: python-Brightify
arch: src
version: 0.1.13
epoch: 0
release: 1
url: https://pypi.org/project/Brightify/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Brightify-0.1.13-1.src.rpm
checksum_type: sha256
summary:
  Brightify is an OS-independent application that adjusts monitor brightness using the DDC/CI protocol and custom protocols for USB monitors, featuring a brightness sensor for automatic adjustments based on ambient light, and can be controlled via a taskbar icon.

description:
  <div align="center">
  <br>
      <img src="brightify/res/icon_light.ico" alt="" width="150" height="auto"/>
      <h1>Brightify</h1>
      <div>
      <a href="https://www.codefactor.io/repository/github/rerikop/brightify"><img src="https://www.codefactor.io/repository/github/rerikop/brightify/badge" alt="CodeFactor" /></a>
      </div>
  <br>
  </div>

  This app allows you to set the brightness of your monitor(s). It is essentially a wrapper around
  the [DDC/CI](https://en.wikipedia.org/wiki/Display_Data_Channel#DDC/CI) protocol, which is supported by most modern monitors.
  It also supports adding custom communication protocols to control the brightness of Monitors connected via USB.
  You can find an example implementation for the [Gigabyte M27Q](https://www.gigabyte.com/Monitor/M27Q)
  in [here](brightify/src_py/monitors/m27q.py).
  The app is designed to be run in the background and can be controlled via a taskbar icon. It also supports a brightness
  sensor that can automatically adjust the brightness based on the ambient light.



  1. Install brightify by running `pip install Brightify`. This package is regularly uploaded to PyPi. If you want to
     install the latest version, you can clone this repository from
     [GitHub](https://github.com/RerikOp/Brightify) and install it with `pip install -e .` in the root directory.
  2. To start the app: `python -m brightify run`. You can exit either by right-clicking the icon in the taskbar and
     selecting "Exit" or by pressing `Ctrl+C` in the terminal.
  3. To start the app at startup (or logon) and add a menu icon, run `python -m brightify add all`. To remove the both,
     run
     `python -m brightify remove all`.


  As the DDC/CI protocol requires write access to the `/dev/i2c-*` devices, you need to add your user to the `i2c` group (or run the script as the root user).
  - First, verify that the group exists by running `getent group i2c`.
    - If it does not exist, you need to create it by running `sudo groupadd i2c` and also assign the `i2c` devices to the group by running `sudo chown root:i2c /dev/i2c-*`.
  - Now you can add your user to the group by running `sudo usermod -aG i2c $USER`. Verify that the user is in the group by running
  `groups $USER` and checking if `i2c` is listed. If running `groups` does not show `i2c`, you need restart the system.
  - Finally, you might need to change the permissions of the `/dev/i2c-*` so that the group has read/write access. You can do this by running `sudo chmod g+rw /dev/i2c-*`.
    - If this change is not permanent you can create a udev rule by creating a file in `/etc/udev/rules.d/` with the content `KERNEL=="i2c-[0-9]*", GROUP="i2c", MODE="0660"`.
    - After creating the file, you need to reload the udev rules by running `sudo udevadm control --reload-rules && sudo udevadm trigger`.
  - To remove the user from the group, run `sudo deluser $USER i2c`.



  There are several other arguments you can pass to the app, see `python -m brightify --help` for more information.

  - To target add/remove only the startup run `python -m brightify add/remove startup`.
      - To add a task to the task scheduler on Windows, pass `--use-scheduler`. It will request elevated permissions.
  - To add/remove only the menu icon run `python -m brightify add/remove menu-icon`.
  - By default, the terminal will be hidden, but you can change this by passing the `--force-console` argument to the `run` or `add` action.
  - To disable animations, pass the `--no-animations` argument to the `run` or `add` action.



  - Modify the [SensorComm](brightify/src_py/SensorComm.py) class to match your device and firmware
  - Modify the code that is polling from the brightness sensor [Device Firmware](brightify/sensor_firmware/src)
  - Modify [platformio.ini](brightify/sensor_firmware/platformio.ini) and enter your board (
    see [supported boards](https://docs.platformio.org/en/latest/boards/index.html))
  - Run `pio run -t upload` in the terminal to upload the firmware to the board.
    If everything is working, the *Auto* Checkbox for each supported Monitor should now be clickable



  - Currently, only the Windows task bar icon is supported, the main part of this app is OS independent.
  - Feel free to create a pull request and add your own USB Monitor
  - Note that a USB Monitor will replace a DDC/CI Monitor with the same name. If you want to use both, you need to change
    the name of your USB Monitor implementation.
    In case a monitor is found but does not send its name, we cannot distinguish between DDC/CI and USB Monitors. In this
    case, both will be added.


pkgId: 12afb0b30590928f6aef636f89833dbb53d0d1889520c215b322869f067ccdcd
name: python-BrosHelp
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: BrosHelp Bot
url: https://github.com/KayShenA/PythonProjects
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrosHelp-0.1.17-1.src.rpm
checksum_type: sha256
description:
  A sample project that exists as an aid to the `Python Packaging User Guide
  <https://packaging.python.org>`_'s `Tutorial on Packaging and Distributing
  Projects <https://packaging.python.org/en/latest/distributing.html>`_.
  This projects does not aim to cover best practices for Python project
  development as a whole. For example, it does not provide guidance or tool


pkgId: f0b573f51d6babc7a3e8a499b337eac70cfc9c7cd780b5ac303609e166189941
name: python-Brotli
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Python bindings for the Brotli compression library
url: https://github.com/google/brotli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Brotli-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/google/brotli/actions/workflows/build_test.yml/badge.svg" alt="GitHub Actions Build Status" href="https://github.com/google/brotli/actions?query=branch%3Amaster">
    <img src="https://oss-fuzz-build-logs.storage.googleapis.com/badges/brotli.svg" alt="Fuzzing Status" href="https://oss-fuzz-build-logs.storage.googleapis.com/index.html#brotli">
  </p>
  <p align="center"><img src="https://brotli.org/brotli.svg" alt="Brotli" width="64"></p>



  Brotli is a generic-purpose lossless compression algorithm that compresses data
  using a combination of a modern variant of the LZ77 algorithm, Huffman coding
  and 2nd order context modeling, with a compression ratio comparable to the best
  currently available general-purpose compression methods. It is similar in speed
  with deflate but offers more dense compression.

  The specification of the Brotli Compressed Data Format is defined in [RFC 7932](https://tools.ietf.org/html/rfc7932).

  Brotli is open-sourced under the MIT License, see the LICENSE file.

  > **Please note:** brotli is a "stream" format; it does not contain
  > meta-information, like checksums or uncompresssed data length. It is possible
  > to modify "raw" ranges of the compressed stream and the decoder will not
  > notice that.





  You can download and install brotli using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:

      git clone https://github.com/Microsoft/vcpkg.git
      cd vcpkg
      ./bootstrap-vcpkg.sh
      ./vcpkg integrate install
      ./vcpkg install brotli

  The brotli port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.



  See [Bazel](http://www.bazel.build/)



  The basic commands to build and install brotli are:

      $ mkdir out && cd out
      $ cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=./installed ..
      $ cmake --build . --config Release --target install

  You can use other [CMake](https://cmake.org/) configuration.



  To install the latest release of the Python module, run the following:

      $ pip install brotli

  To install the tip-of-the-tree version, run:

      $ pip install --upgrade git+https://github.com/google/brotli

  See the [Python readme](python/README.md) for more details on installing
  from source, development, and testing.



  We glad to answer/library related questions in
  [brotli mailing list](https://groups.google.com/forum/#!forum/brotli).

  Regular issues / feature requests should be reported in
  [issue tracker](https://github.com/google/brotli/issues).

  For reporting vulnerability please read [SECURITY](SECURITY.md).

  For contributing changes please read [CONTRIBUTING](CONTRIBUTING.md).


  * [Squash Compression Benchmark](https://quixdb.github.io/squash-benchmark/) / [Unstable Squash Compression Benchmark](https://quixdb.github.io/squash-benchmark/unstable/)
  * [Large Text Compression Benchmark](http://mattmahoney.net/dc/text.html)
  * [Lzturbo Benchmark](https://sites.google.com/site/powturbo/home/benchmark)


  > **Disclaimer:** Brotli authors take no responsibility for the third party projects mentioned in this section.

  Independent [decoder](https://github.com/madler/brotli) implementation by Mark Adler, based entirely on format specification.

  JavaScript port of brotli [decoder](https://github.com/devongovett/brotli.js). Could be used directly via `npm install brotli`

  Hand ported [decoder / encoder](https://github.com/dominikhlbg/BrotliHaxe) in haxe by Dominik Homberger. Output source code: JavaScript, PHP, Python, Java and C#

  7Zip [plugin](https://github.com/mcmilk/7-Zip-Zstd)

  Dart [native bindings](https://github.com/thosakwe/brotli)

  Dart compression framework with [fast FFI-based Brotli implementation](https://pub.dev/documentation/es_compression/latest/brotli/brotli-library.html) with ready-to-use prebuilt binaries for Win/Linux/Mac


pkgId: 27b57db6b1cb0604adb0226f51eb3fab8f6a0d155bee8a3e37aedd5cf731a327
name: python-BrownieCutter
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: Quick script to create new python project
url: https://github.com/thiswillbeyourgithub/BrownieCutter
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BrownieCutter-0.1.15-1.src.rpm
checksum_type: sha256
description:
  * I just needed a quick script to lower the time cost of creating new FOSS tools. So just run this script, give the project name and class name and you'll get a proper template dir with some boiletplate code done for you.
  * Yes BrownieCutter was created by itself.
  * Inspired by [CookieCutter](https://cookiecutter.readthedocs.io/).


  * As an uv tool: `uvx BrownieCutter@latest --help`
  * From pypi: `uv pip install BrownieCutter` or `pip install BrownieCutter`
  * From git: git clone then `pip install .`
  * `BrownieCutter --help`


pkgId: 20e16ece3083efe365805f0c93f946a9452785760487990679f3a342324a2205
name: python-BubbleTea-py
arch: src
version: 0.0.7
epoch: 0
release: 1
url: https://github.com/scout-cool/BubbleTea
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BubbleTea-py-0.0.7-1.src.rpm
checksum_type: sha256
summary:
  BubbleTea enables developers to quickly build any data applications on the emerging Web3 infrastructure.

description:
  Bubbletea
  --

  A python library which enables developers and data scientists to quickly build any data applications on top of The Graph network. Whether you are building dashboards to visualize protocol data or leveraging existing machine learning models to do some data science work, we hope this library will be the fastest way to get what you want.

  This project is made possible by a grant (wave 2) from The Graph foundation.


  - An improved way to query data from The Graph network
  - A set of handy functions for common data transformations (built on Pandas)
  - A set of out-of-box charting components to make visualizations effortless (built on Altair)
  - A simple templating system to build dashboards (built on Streamlit)


  pip install BubbleTea-py









  https://twitter.com/scout_cool


pkgId: 061f22e815f73d04c5ab11d61333cc81baca9822ba0f919691adac620357e4c1
name: python-Bubot-AuthService
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Service providing authentication capabilities for the Bubot framework
url: https://github.com/businka/Bubot_AuthService
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Bubot-AuthService-4.0.1-1.src.rpm
checksum_type: sha256
description:
  Service providing authentication capabilities for the Bubot framework



  This published under the MIT License, see [LICENSE](LICENSE) for details.


  Copyright (c) 2020 Mikhail Razgovorov <http://razgovorov.ru/>,


pkgId: f30d1625d7d9b881ed34b75565361421524354cffeede2438e97b0b7c6682f8f
name: python-BucketCache
arch: src
version: 0.12.1
epoch: 0
release: 1
summary: Versatile persisent file cache.
url: https://github.com/RazerM/bucketcache
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BucketCache-0.12.1-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |PyPI Version| |Python Version| |MIT License|
  Installation
  ~~~~~~~~~~~~
      $ pip install bucketcache
  Quick Overview
  ~~~~~~~~~~~~~~
  In one sentence, ``Bucket`` is a container object with optional lifetime
  backed by configurable serialisation methods that can also act as a
  function or method decorator.
  Before everything is explained in detail, here's a quick look at the
  functionality:
  Container:
      from bucketcache import Bucket
      bucket = Bucket('cache', hours=1)
      bucket[any_object] = anything_serializable_by_backend  # (Pickle is the default)
  Decorator:
      class SomeService(object):
          def __init__(self, username, password):
              self.username = username
              self.password = password
          @bucket(method=True, nocache='skip_cache')
          def expensive_method(self, a, b, c, skip_cache=False):
              print('Method called.')
          @expensive_method.callback
          def expensive_method(callinfo):
              print('Cache used.')
      some_service = SomeService()
      some_service.expensive_method(1, 2, 3)
      some_service.expensive_method(1, 2, 3)
      some_service.expensive_method(1, 2, 3, skip_cache=True)
      Method called.
      Cache used.
      Method called
  For in-depth information, `visit the
  documentation <http://bucketcache.readthedocs.io/>`__!


pkgId: 8c41ac0b38b8a19d64229d9addce3d32f226afe3460ce67f6127cc3f61ebdc58
name: python-BugScanX
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: All in one toolkit for SNI bughost analysis
url: https://github.com/ayanrajpoot10/BugScanX
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BugScanX-1.0.5-1.src.rpm
checksum_type: sha256
description:
  BugScanX is packed with powerful tools to streamline your SNI bug hunting process:
  - ⚡ **Host Checker**: A professional-grade host checker with multiple scanning modes and HTTP methods.
  - 🖥️ **Subdomains Scanner**: Detect subdomains that might indicate SNI bug hosts.
  - 📡 **IP Addresses Scanner**: Analyze specific IP addresses to find potential SNI bug hosts.
  - 🌐 **Subdomains Finder**: Identify active subdomains associated with a target domain.
  - 🔍 **Domains Hosted on Same IP**: List other domains hosted on the same IP as a given target.
  - 🧰 **TXT Toolkit**: A versatile toolkit for handling text files—split, clean, remove duplicates, and more.
  - 🔓 **Open Port Checker**: Scan for open ports on a given IP address or domain.
  - 📜 **DNS Records**: Retrieve A, MX, TXT, and other DNS records of any domain.
  - 💡 **Host OSINT**: Gather open-source intelligence (OSINT) on any host.
  - 📖 **Help**: Provides detailed usage instructions for every tool.
  - ⛔ **Exit**: Clean exit from the script.


pkgId: d8d6d468521823457757419d797a7afe4beb717052ac7066fd43ca3db762ecbb
name: python-BuildABot
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Build a Dicord bot with ease and flexibility
url: https://gitlab.com/artex-development/bot_framework
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BuildABot-2.0.4-1.src.rpm
checksum_type: sha256
description:
  Build a Dicord bot with ease and flexibility
  For editing module repo: _Before replacing *anything* with modules from elsewhere, and I can't stress this enough, you **MUST** read the new and old files carefully to verify that you indeed have the latest version of the module. Check every file, every method, *every line* that you are not overriding things so that they are lost forever and you have to spend another 8 hours recreating it._

  - All files are lowercase and snake case
  - module names start with an uppercase letter (except for cases like jQuery) and are CamelCase
    - With acronyms, only capitilize the first letter if longer than 2 characters (ie. Url, DB, Http, AV)
  - Descriptions are required, but don't need to be detailed
  - All modules must have a README
    - For modules in a folder, or foldered modules, name it `README.md` and put it alongside the `module.json`
    - For single file modules, put the readme in `__READMES__` with the same name as the module file (ie. `./my_module.py` => `./__READMES__/my_module.md`)
  - For single file modules make sure your meta is in the following format
    ```python
    meta = {
    } ## BuildABot -- end
    ```
    this is so the automated bot maker can properly identify the module depencencies, but is not nessesary for non-public modules
  - Verify all dependencies, soft dependencies, and requirements are there, none are missing, and there are none extra
  - If nessesary have `defaultConfig` is in the module meta
  - Change nothing without doing what it says at the top
  - modules should be independent and should not throw errors on_load, on_enable, and on_disable
  - The more config options, the better


  To start, you have two options; create a single file module or a folder. You should use a folder if you plan to have, commands, locale, many classes, or complex logic.

  1. Create your file in `src/modules` (`echo "" > src/modules/my_module.py`)
  2. import buildabot module (`from buildabot import module`)
  3. create a var called `meta` and assign a dict, more info about module metas below (`meta = {}`)
      - End the dict with `} ## BuildABot -- end` if it is a public module
  4. create a class that extends `module` (`class Mymodule(module):`)

  1. Create a folder, choose a folder name close to your modules' (`mkdir src/modules/my_module`)
  2. Change to that folder (`cd src/modules/my_module`)
  3. Create `module.json` and create an object inside, more info about module metas below (`echo "{}" > module.json`)
  4. Create a python file with whatever name, I'd reccomend the same as your folder (`echo "" > my_module.py`)
  5. import buildabot module (`from buildabot import module`)
  6. create a class that extends `module` (`class Mymodule(module):`)
  Now that you have the basic setup done, it's time to setup your module meta

  module Meta is something that tells BuildABot what your module does and how to get things rolling. The meta is an object (or dict), here is a list of all properties you can use, some are required
  | Key | Type | Default | Info |
  |---|---|---|---|
  | class | string | n/a | Starting class of the module, more info below |
  | name | string | n/a | Name of the module |
  | description | string | n/a | What the module does, be as short or complex as you need |
  | ?depends | string[] | [] | module dependencies |
  | ?softDepends | string[] | [] | Optional module dependencies |
  | ?defaultConfig | object | {} | Default config for the module |
  | ?requirements | string[] | [] | Pypi requirements for the module |
  | ?threaded | boolean | false | module uses threading. modules that have this true can not be disabled |
  | ?disable | boolean | false | modules that have this true will not be enabled |
  | ?experimental | boolean | false | Experimental modules should be used causiously as they might not behave as expected. |
  Example Meta:
  ```json
  {
    "class": "my_module.Mymodule",
    "name": "Mymodule",
    "description": "My module is an awesome module that enables the bot to do some really awesome stuff!",
    "depends": [],
    "softDepends": [
      "Commands"
    ],
    "defaultConfig": {
      "awesomeFactor": 1.42
    },
    "requirements": ["pytz"],
    "threaded": false,
    "disable": false,
    "experimental": false
  }
  ```
  If for some reason your module needs to access your or another feautres meta you can do `module#meta`

  - For single file modules, set `class` as the name of the class that extends `module`
  - For folder modules, class should be set to the import of the class that extends `module` from the module folder (ie. `settings.SnowflakeSettings`, in the file `settings.py` with the class named `SnowflakeSettings`)

  - `def on_load(self)` - called when module is loaded, don't attempt to access other modules as they may not be loaded yet
  - `async def on_enable(self)` - called when the module is enabled, now is when you can garentee you dependencies will be loaded
  - `async def on_disable(self)` - called when module is disabled, more offten than not this won't be called when the bot stops

  Events are listened using `module#on_event(event_name, listener_func, [namespace="discord"], [priority=0], [ignore_canceled=False])`, event names can be found on the [discord.py](https://discordpy.readthedocs.io/en/latest/api.html#event-reference) documentation, in addition here are the built-in events, the namespace is `buildabot`:
  - `on_ready` - Called when the module manager is setup
  - `on_done` - Called after enable process is finished (after `on_all_enabled`)
  - `on_all_load` - Called after all modules are loaded, useful to add or modify functions in each module
  - `on_load` - Called once a module has been loaded, useful to add or modify a dependant module
  - `on_all_enabled` - Called when all modules have been enabled
  - `on_enabled` - Called once a module has been enabled
  - `on_all_disabled` - Called when all modules have been disabled
  - `on_disable` - Called once a module has been disabled
  _**Important:** All listener functions must be a coroutine. In order to turn a function into a coroutine they must be `async def` functions_
  Each module may have their own events, you can read about them in the modules' README
  To create an event, it's pretty simple, in your `on_load` define the module with `self.module_manager.define_event(event_name)` then to call the event run either `await self.module_manager.emit_event(namespace, event_name, *args, **kwargs)` or `self.module_manager.emit_event_sync(namespace, event_name, *args, **kwargs)`

  Using other modules is pretty easy, it's as simple as doing `self.module_manager.get_module("SomeOthermodule")`. But before you use any module you should put the module in your dependiencies, this prevents any errors and garentees the module is there when your module is enabled. If you were to soft depend a module then you should always check if the module is enabled before using it, `self.module_manager.is_enabled("SomeOthermodule")`

  Because commands are so common, I thought it'd be a good idea to tell you how to use the Commands module, but more detailed info will be in the Commands README. First of all, Commands requires EmbedUI and works best with SnowflakeSettings installed, and second your module should be in a folder to be the cleanest, the tutorial will be for foldered modules only.
  1. To get setup you first want to create a new directory in your module directory called anything you want, but it's common to call it `cmds`
  2. Now, hooking into Commands is easy, as ushal you want to put Commands into your soft dependencies.
  3. Next copy this code snippit into your on_enable
  ```python
  if self.module_manager.is_enabled("Commands"):
      from modules.commands.command_manager import CommandManager # import CommandManager for type hinting
      cmd: CommandManager = self.module_manager.get_module("Commands") # Get the command manager
      cmd.add_command_dir('my_module/cmds', ftr_dir=True) # Tell the command manager where your commands are
      cmd.add_type("my", "My module", after='info') # More info in Commands README
  ```
  This snippit will get the Commands command manager and tell it where to look for your commands, this isnt the only way to add commands, but it is the cleanest.
  - Now in your modules' commands directory, create a new python file, the name of the file will be the name of the command (ie `my_command.py`)
  - Inside the file put the following code (remove comments if you want)
  ```python
  from modules.commands.command import Command
  from modules.commands.command_context import CommandContext
  meta = {
      'class': 'MyCommand',
      'description': "A command that does cool stuff",
      'usage': '',
      'pack': 'my_module',
      'type': "my",
      'permissions': []
  } # More info in Commands README
  class MyCommand(Command):
      async def on_command(self, context: CommandContext): # Called when the user runs the command, more info in Commands README
          await context.ok("{}, my command is the coolest command!".format(context.author.mention)) # Replys to the channel using EmbedUI
  ```

  This is a foldered module
  `src/modules/my_module/module.json`
  ```json
  {
    "class": "my_module.Mymodule",
    "name": "Mymodule",
    "description": "My module is an awesome module that enables the bot to do some really awesome stuff!",
    "depends": [
      "MongoDB"
    ],
    "softDepends": [
      "Commands"
    ],
    "defaultConfig": {
      "awesomeFactor": 1.42
    },
  }
  ```
  `src/modules/my_module/my_module.py`
  ```python
  from buildabot import module
  class Mymodule(module):
      def __init__(self, fm, m):
          super().__init__(fm, m)
          self.collection = None
      async def on_enable(self):
          self.collection = self.module_manager.get_module("MongoDB").collection("my_module")
          if self.module_manager.is_enabled("Commands"):
              from modules.commands.command_manager import CommandManager
              cmd: CommandManager = self.module_manager.get_module("Commands")
              cmd.add_command_dir('my_module/cmds', ftr_dir=True)
              cmd.add_type("my", "My module", after='info')
              cmd.add_alias("add", "my")
              cmd.add_alias("count", "my")
  ```
  `src/modules/my_module/cmds/my.py`
  ```python
  import discord
  from modules.commands.command import Command
  from modules.commands.command_context import CommandContext
  meta = {
      'class': 'My', # Class of the command
      'description': "A command that does cool stuff", # What the command does
      'usage': '<number>', # Tells the user the command usage in the help command
      'pack': 'my_module', # Used to disable specific module commands in the Commands config
      'type': "my", # In the "My module" category in the help command
      'permissions': ['administrator'] # WIll require the user to have the `administrator` permission
      
  }
  class My(Command):
      async def on_command(self, context: CommandContext):
          
          if len(context.args) < 1:
              raise context.MissingArgsException(context)
          
          try:
              add = int(context.args[0])
          except:
              
              await context.error("That's not a number")
              return
          
          result = self.command_manager.get_module("Mymodule").collection.update_one(
              {"user": context.author.id}, {"$add": {"count": add}}, {"upsert": True})
          
          count = result.raw_result["count"]
          
          await context.ok(f"Your counter is now at {count}")
  ```


pkgId: 304fc77a9cf2a1f9ec9b49b7005706ba1b2568799de03e958e7791e83972bf52
name: python-BunnyPy
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Lightweight Python Web Framework
url: https://github.com/ivanlulyf/bunnypy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BunnyPy-0.3.3-1.src.rpm
checksum_type: sha256
description:
  a Lightweight Python Web Framework

  ![BunnyPy](logo.png?raw=true)

  [![PyPI](https://img.shields.io/pypi/v/bunnypy.svg?style=flat-square)](https://pypi.org/project/BunnyPy/)
  [![Downloads](https://img.shields.io/pypi/dm/bunnypy.svg?color=brightgreen&style=flat-square)](https://pypi.org/project/BunnyPy/)
  [![License](https://img.shields.io/pypi/l/bunnypy.svg?color=blue&style=flat-square)](LICENSE)

  English | [中文](README_CN.md)



  ```shell
  pip install bunnypy
  ```



  a HelloWord Application

  ```python
  from bunnypy import Bunny

  app = Bunny()

  @app.controller
  class IndexController:
      def ac_index(self):
          return 'Hello Bunny'

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



  ```python
  from bunnypy import Bunny
  import sqlite3




  db = Bunny.SQLiteDatabase(sqlite3.connect('test.db'), 'tp_')
  app = Bunny(database=db)





  @app.data
  class Message:
      __pk__ = ['id']
      __ai__ = 'id'
      id = 'integer not null'
      msg = 'text not null'

      def __init__(self, msg=None):
          self.msg = msg





  Message.create() # create a table named "tp_message"




  Message(msg="New Message").insert() # add a new row into table "tp_message"





  Message.where(" msg = ? ",["Test"]).get(['id','msg'])


  size = 10
  start = 0
  Message.where().order(' id desc ').limit(size,start).get_all(['id','msg'])

  ```



  ```temp.html``` in ```template``` dir

  ```html
  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <title>Template</title>
  </head>
  <body>
  Output: {{ msg }}
  </body>
  </html>
  ```

  Python code

  ```python
  from bunnypy import Bunny

  app = Bunny()

  @app.controller
  class IndexController:
      def ac_index(self):
          return app.render('temp.html',{"msg":"Hello World"})


  if __name__ == '__main__':
      app.run()

  ```


pkgId: 2341a58382e9f38294b5745679f4f5779e7a0b4305c59c23d8c35d3b81af6b7d
name: python-Burningkeys
arch: src
version: 2024.12.7
epoch: 0
release: 1
summary: Turns any text any editor into a super customisable editor (by allowing to set global hotkeys)
url: https://pypi.org/project/Burningkeys/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Burningkeys-2024.12.7-1.src.rpm
checksum_type: sha256
description:
  Burningkeys is a lightweight python script to invoke certain commands using hotkeys. This cli is meant mainly for
  coding. For example you might be editing in a basic text editor and would like to invoke a linter on your project. Well
  now you can set that up.

  Basically I don't like vim, but would like to have vim.


pkgId: 1a14159ca069e288bc149ba2a9628e25d989d37037da508680595b4e3acc61a0
name: python-BusyBox
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: dependency injector
url: https://github.com/AngelovLee/BusyBox
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BusyBox-1.0.3-1.src.rpm
checksum_type: sha256
description:
  - 该类库主要提供多种类注入方式， 主要利用抽象类，解决python中原生无接口的工程方面的缺陷
  > 示例一:
  - 单实例化
  ```python
  from BusyBox.ServiceBox import Box

  class AppleService(object):

      def name(self):
          return 'test'

  if __name__ == '__main__':
      box = Box()
      box.inject(AppleService)
      box.apple_service.name()
  ```
  > 示例二:
  - 带参 多实例化
  ```python
  from BusyBox.ServiceBox import Box

  class TestService(object):

      def __init__(self, params1):
          self.params1 = params1

      def handle(self):
          return self.params1


  class RestService(object):

      def __init__(self, params1):
          self.params1 = params1

      def handle(self):
          return self.params1

  if __name__ == '__main__':
      box = Box()
      box.inject(TestService, RestService, payload=dict(params1=1))
      box.rest_service.handle()
      box.test_service.handle()
  ```
  > 示例三:
  - 类命名中带实例
  ```python
  from BusyBox.ServiceBox import Box

  class Bus1Service(object):

      def name(self):
          return 'test'

  if __name__ == '__main__':
      box = Box()
      box.inject(Bus1Service)
      box.bus1_service.name()
  ```
  > 示例四:
  - 类命名中带实例
  ```python
  from BusyBox.ServiceBox import Box

  box = Box()

  @box.depend()
  class CowService(object):

      @staticmethod
      def name():
          return 'test'

  if __name__ == '__main__':
      box = Box()
      box.inject(CowService)
      box.cow_service.name()
  ```
  > 示例五:
  - __init__方法带参实例
  ```python
  from BusyBox.ServiceBox import Box

  box = Box()

  @box.depend()
  class EasyService(object):

      def __init__(self, params1, *args, **kwargs):
          self.args = args
          self.kwargs = kwargs
          self.params1 = params1

      def name(self):
          return self.params1, self.args, self.kwargs

  if __name__ == '__main__':
      box = Box()
      box.invoke('easy_service', 1, 2, 3, a=4, b=5)
      box.easy_service.name()
  ```
  > 示例六:
  - 注入参数 在__init__参数中不需要时，在有没有kwargs参数情况下会忽略
  ```python
  from BusyBox.ServiceBox import Box
  class PositionService(object):

      def __init__(self, params1: str):
          self.params1 = params1

      def show_params(self):
          print(f'{__class__}: self.params1:', self.params1)
          return self.params1
  if __name__ == '__main__':
      box = Box()
      box.inject(PositionService, payload={'params1': 1, 'params2': 1})
      box.position_service.show_params()
      """
      输出：
          <class 'TestInjectorDemo.PositionService'>: self.params1: 1
      """
  ```
  > 示例七:
  - 实体重置复用
  ```python
  from BusyBox.ServiceBox import Box

  class Position4Service(object):

      def __init__(self, params1: str, *_args, **_kwargs):
          self.params1 = params1
          self.args = _args
          self.kwargs = _kwargs

      def show_params1(self):
          print('self.params1:', self.params1)
          return self.params1

      def show_args(self):
          print('self._args:', self.args)
          return self.args

      def show_kwargs(self):
          print('self._kwargs:', self.kwargs)
          return self.kwargs
  if __name__ == '__main__':
      box = Box()
      box.inject(Position4Service, args_payload=(99, 1, 2, 3, 4), kwargs_payload=dict(params2=88))
      box.position4_service.show_params1() == 99              # True
      box.position4_service.show_args() == (1, 2, 3, 4)       # True
      box.position4_service.show_kwargs() == dict(params2=88) # True
      box.position4_service.params1 = 100                     # True
      box.position4_service.show_params1() == 100
      
      box.reset('position4_service')
      box.position4_service.show_params1() == 99              # True
      box.position4_service.show_args() == (1, 2, 3, 4)       # True
      box.position4_service.show_kwargs() == dict(params2=88) # True
  ```
  > 实例八
  - 服务中根据依赖服务的接口注入相关工厂
  ```python
  import abc
  from BusyBox.ServiceBox import FactoryInjectAPI, factory_inject

  class Child1API(metaclass=abc.ABCMeta):
      def func1(self) -> str:
          raise NotImplementedError


  class Child2API(metaclass=abc.ABCMeta):
      def func2(self) -> str:
          raise NotImplementedError


  class Child1Service(Child1API):

      def func1(self) -> str:
          return "func1"


  class Child2Service(Child2API):

      def func2(self) -> str:
          return "func2"


  class Child1ServiceFactory(FactoryInjectAPI):

      def construct(self) -> Child1API:
          return Child1Service()


  class Child2ServiceFactory(FactoryInjectAPI):

      def construct(self) -> Child2API:
          return Child2Service()


  @factory_inject(
      Child1ServiceFactory,
      Child2ServiceFactory
  )
  class FatherService(object):

      child1_service: Child1API
      child2_service: Child2API

      def __init__(self):
          print('')

      def test(self):
          print('test:', self.child1_service.func1(), self.child2_service.func2())
  ```
  > 实例九
  - 依赖的服务共享宿主实例的属性
  ```python

  import abc
  from typing import Any
  from BusyBox.ServiceBox import FactoryInjectAPI, factory_inject


  class Child1RefAPI(metaclass=abc.ABCMeta):

      @abc.abstractmethod
      def func1(self) -> str:
          raise NotImplementedError


  class Child2RefAPI(metaclass=abc.ABCMeta):

      @abc.abstractmethod
      def func2(self) -> str:
          raise NotImplementedError


  class Context(object):
      session: Any

      def __init__(self, session: Any):
          self.session = session


  class Child1RefService(Child1RefAPI):
      context: Context

      def __init__(self, ctx: Context):
          self.context = ctx

      def func1(self) -> str:
          return f"Child {self.context} {id(self.context)}"


  class Child2RefService(Child2RefAPI):
      context: Context

      def __init__(self, ctx: Context):
          self.context = ctx

      def func2(self) -> str:
          return f"Child {self.context} {id(self.context)}"


  class Child1RefServiceFactory(FactoryInjectAPI):

      def construct(self, context: Context) -> Child1RefAPI:
          return Child1RefService(context)


  class Child2RefServiceFactory(FactoryInjectAPI):

      def construct(self, context: Context) -> Child2RefAPI:
          return Child2RefService(context)


  @factory_inject(
      Child1RefServiceFactory,
      Child2RefServiceFactory,
      refer=Context
  )
  class FatherDeepService(object):

      child1_service: Child1RefAPI
      child2_service: Child2RefAPI
      context_host: Context

      def __init__(self):
          self.context_host = Context('context from host')
          print(f'Host {self.context_host} {id(self.context_host)}')

      def test(self):
          print('test:', self.child1_service.func1(), self.child2_service.func2())
  if __name__ == '__main__':
      f_srv = FatherDeepService()
      assert f_srv.child1_service.func1() == f_srv.child2_service.func2()
      assert f_srv.context_host == f_srv.child1_service.context
  ```


pkgId: b09e3f17794b43c418def0ef846f01afb5e3f35c77602508699580f43d143917
name: python-ButterflyNet
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A better networking library.
url: https://butterflynet.veriny.tf
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ButterflyNet-1.1.0-1.src.rpm
checksum_type: sha256
description:
  .. figure:: https://butterflynet.veriny.tf/bnet.png
     :alt: ButterflyNet - Drawn by Tudor Iacobescu

  |Build Status| |PyPI version|
  |https://img.shields.io/pypi/l/ButterflyNet.svg|
  |https://img.shields.io/pypi/dw/ButterflyNet.svg|

  ButterflyNet is an server-side batteries-included secure networking
  framework built upon
  `asyncio <https://docs.python.org/3/library/asyncio.html>`__.

  | All code in ButterflyNet is designed to be asynchronous by default,
    with special cases made for non-async code such as external libraries.
  | Because of the heavy usage of asyncio, this module does not officially
    support Python versions before 3.4. It may be possible to run it with
    a backported tulip library, but no official support will be given for
    this.

  Why ButterflyNet?
  ~~~~~~~~~~~~~~~~~

  ButterflyNet was designed for a few main reasons:

  -  Sockets are low-level; personally, I dislike them because they're not
     the friendliest thing to use.
  -  Twisted has a steep learning curve, and has a lot of cruft.
  -  asyncio networking is good, but it's very hands-off - ButterflyNet
     comes with everything needed for a full networking suite.

  All the existing libraries are not, by design, secure. You can work
  around this with SSLContexts - however, ButterflyNet forces TLS with
  secure settings on your server by default.

  Getting Started
  ~~~~~~~~~~~~~~~

  ButterflyNet is available to download off of PyPI:
  ``pip install ButterflyNet``

  | Documentation can be found `here <https://butterflynet.veriny.tf>`__.
  | Examples can be found `here </examples>`__.

  Limitations
  ~~~~~~~~~~~

  You have a choice of TCP or UDP in most networking frameworks. However,
  ButterflyNet is designed upon persistent, TLS-authenticated and secured
  connections, of which UDP has:

  -  No persistent connections
  -  Unreliable TLS security

  This means ButterflyNet is locked to TCP for the future. OpenSSL *does*
  support DTLS, but no support for this is planned.

  .. |Build Status| image:: https://img.shields.io/circleci/project/SunDwarf/ButterflyNet.svg
     :target: https://circleci.com/gh/SunDwarf/ConfigMaster/
  .. |PyPI version| image:: https://img.shields.io/pypi/v/ButterflyNet.svg
     :target: https://pypi.python.org/pypi/ButterflyNet/
  .. |https://img.shields.io/pypi/l/ButterflyNet.svg| image:: https://img.shields.io/pypi/l/ButterflyNet.svg
  .. |https://img.shields.io/pypi/dw/ButterflyNet.svg| image:: https://img.shields.io/pypi/dw/ButterflyNet.svg


pkgId: f743fb478ca0b43ac84059b5b4865676abb86f6929661d25c613e3b70c25b161
name: python-BytecodeAssembler
arch: src
version: 0.6.1
epoch: 0
release: 1
url: http://pypi.python.org/pypi/BytecodeAssembler
rpm_license: ZPL 2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BytecodeAssembler-0.6.1-1.src.rpm
checksum_type: sha256
summary:
  Generate Python code objects by "assembling" bytecode (Now includes a functional/AST-oriented API, too!)

description:
  ``peak.util.assembler`` is a simple bytecode assembler module that handles most
  low-level bytecode generation details like jump offsets, stack size tracking,
  line number table generation, constant and variable name index tracking, etc.
  That way, you can focus your attention on the desired semantics of your
  bytecode instead of on these mechanical issues.

  In addition to a low-level opcode-oriented API for directly generating specific
  Python bytecodes, this module also offers an extensible mini-AST framework for
  generating code from high-level specifications.  This framework does most of
  the work needed to transform tree-like structures into linear bytecode
  instructions, and includes the ability to do compile-time constant folding.

  Please see the `BytecodeAssembler reference manual`_ for more details.

  .. _BytecodeAssembler reference manual: http://peak.telecommunity.com/DevCenter/BytecodeAssembler#toc


  Changes since version 0.6:

  * Fix bad stack calculations for BUILD_CLASS opcode

  Changes since version 0.5.2:

  * Symbolic disassembly with full emulation of backward-compatible
    ``JUMP_IF_TRUE`` and ``JUMP_IF_FALSE`` opcodes on Python 2.7 -- tests now
    run clean on Python 2.7.

  * Support for backward emulation of Python 2.7's ``JUMP_IF_TRUE_OR_POP`` and
    ``JUMP_IF_FALSE_OR_POP`` instructions on earlier Python versions; these
    emulations are also used in BytecodeAssembler's internal code generation,
    for maximum performance on 2.7+ (with no change to performance on older
    versions).

  Changes since version 0.5.1:

  * Initial support for Python 2.7's new opcodes and semantics changes, mostly
    by emulating older versions' behavior with macros.  (0.5.2 is really just
    a quick-fix release to allow packages using BytecodeAssembler to run on 2.7
    without having to change any of their code generation; future releases will
    provide proper support for the new and changed opcodes, as well as a test
    suite that doesn't show spurious differences in the disassembly listings
    under Python 2.7.)

  Changes since version 0.5:

  * Fix incorrect stack size calculation for ``MAKE_CLOSURE`` on Python 2.5+

  Changes since version 0.3:

  * New node types:

    * ``For(iterable, assign, body)`` -- define a "for" loop over `iterable`

    * ``UnpackSequence(nodes)`` -- unpacks a sequence that's ``len(nodes)`` long,
      and then generates the given nodes.

    * ``LocalAssign(name)`` -- issues a ``STORE_FAST``, ``STORE_DEREF`` or
      ``STORE_LOCAL`` as appropriate for the given name.

    * ``Function(body, name='<lambda>', args=(), var=None, kw=None, defaults=())``
      -- creates a nested function from `body` and puts it on the stack.

    * ``If(cond, then_, else_=Pass)`` -- "if" statement analogue

    * ``ListComp(body)`` and ``LCAppend(value)`` -- implement list comprehensions

    * ``YieldStmt(value)`` -- generates a ``YIELD_VALUE`` (plus a ``POP_TOP`` in
      Python 2.5+)

  * ``Code`` objects are now iterable, yielding ``(offset, op, arg)`` triples,
    where `op` is numeric and `arg` is either numeric or ``None``.

  * ``Code`` objects' ``.code()`` method can now take a "parent" ``Code`` object,
    to link the child code's free variables to cell variables in the parent.

  * Added ``Code.from_spec()`` classmethod, that initializes a code object from a
    name and argument spec.

  * ``Code`` objects now have a ``.nested(name, args, var, kw)`` method, that
    creates a child code object with the same ``co_filename`` and the supplied
    name/arg spec.

  * Fixed incorrect stack tracking for the ``FOR_ITER`` and ``YIELD_VALUE``
    opcodes

  * Ensure that ``CO_GENERATOR`` flag is set if ``YIELD_VALUE`` opcode is used

  * Change tests so that Python 2.3's broken line number handling in ``dis.dis``
    and constant-folding optimizer don't generate spurious failures in this
    package's test suite.


  Changes since version 0.2:

  * Added ``Suite``, ``TryExcept``, and ``TryFinally`` node types

  * Added a ``Getattr`` node type that does static or dynamic attribute access
    and constant folding

  * Fixed ``code.from_function()`` not copying the ``co_filename`` attribute when
    ``copy_lineno`` was specified.

  * The ``repr()`` of AST nodes doesn't include a trailing comma for 1-argument
    node types any more.

  * Added a ``Pass`` symbol that generates no code, a ``Compare()`` node type
    that does n-way comparisons, and ``And()`` and ``Or()`` node types for doing
    logical operations.

  * The ``COMPARE_OP()`` method now accepts operator strings like ``"<="``,
    ``"not in"``, ``"exception match"``, and so on, as well as numeric opcodes.
    See the standard library's ``opcode`` module for a complete list of the
    strings accepted (in the ``cmp_op`` tuple).  ``"<>"`` is also accepted as an
    alias for ``"!="``.

  * Added code to verify that forward jump offsets don't exceed a 64KB span, and
    support absolute backward jumps to locations >64KB.

  Changes since version 0.1:

  * Constant handling has been fixed so that it doesn't confuse equal values of
    differing types (e.g. ``1.0`` and ``True``), or equal unhashable objects
    (e.g. two empty lists).

  * Removed ``nil``, ``ast_curry()`` and ``folding_curry()``, replacing them with
    the ``nodetype()`` decorator and ``fold_args()``; please see the docs for
    more details.

  * Added stack tracking across jumps, globally verifying stack level prediction
    consistency and automatically rejecting attempts to generate dead code.  It
    should now be virtually impossible to accidentally generate bytecode that can
    crash the interpreter.  (If you find a way, let me know!)

  Changes since version 0.0.1:

  * Added massive quantities of new documentation and examples

  * Full block, loop, and closure support

  * High-level functional code generation from trees, with smart labels and
    blocks, constant folding, extensibility, smart local variable names, etc.

  * The ``.label()`` method was renamed to ``.here()`` to distinguish it from
    the new smart ``Label`` objects.

  * Docs and tests were moved to README.txt instead of assembler.txt

  * Added a demo that implements a "switch"-like statement template that shows
    how to extend the code generation system and how to abuse ``END_FINALLY``
    to implement a "computed goto" in bytecode.

  * Various bug fixes

  There are a few features that aren't tested yet, and not all opcodes may be
  fully supported.  Also note the following limitations:

  * Jumps to as-yet-undefined labels cannot span a distance greater than 65,535
    bytes.

  * The ``dis()`` function in Python 2.3 has a bug that makes it show incorrect
    line numbers when the difference between two adjacent line numbers is
    greater than 255.  (To work around this, the test_suite uses a later version
    of ``dis()``, but do note that it may affect your own tests if you use
    ``dis()`` with Python 2.3 and use widely separated line numbers.)

  If you find any other issues, please let me know.

  Please also keep in mind that this is a work in progress, and the API may
  change if I come up with a better way to do something.

  Questions and discussion regarding this software should be directed to the
  `PEAK Mailing List <http://www.eby-sarna.com/mailman/listinfo/peak>`_.

  .. _toc:


pkgId: 21729c2ee0e68b374fcf5f00a3912bae2c09b81f68525e9830cd90399bd60156
name: python-BytesOp
arch: src
version: 0.10
epoch: 0
release: 1
summary: Bitwise operations on bytestrings.
url: https://github.com/janbrohl/BytesOp
rpm_license: OSI Approved
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-BytesOp-0.10-1.src.rpm
checksum_type: sha256
description:
  BytesOp is an extension library providing fast bitwise operations on bytes-like objects for Python 2 and 3.


pkgId: 847594bbf328e4203911e59532035b63e6a6b7612c9553f27f598e4fc511a761
name: python-CACodeFramework
arch: src
version: 1.3.1.2
epoch: 0
release: 1
url: https://gitee.com/cacode_cctvadmin/CACodeFramework-python-ORM
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CACodeFramework-1.3.1.2-1.src.rpm
checksum_type: sha256
summary:
  CACode Framework For Python Flask,This framework corresponds to the ORM problem,You can see:https://gitee.com/cacode_cctvadmin/CACodeFramework-python-ORM

description:
  <h1 align="center">Welcome to CACodeFramework 👋</h1>
  <p>
    <img alt="Version" src="https://img.shields.io/badge/version-Test--1.0.0-blue" />
    <img src="https://img.shields.io/badge/python-%3E%3D%203.6-blue.svg" />
    <img src="https://img.shields.io/badge/simplejson-%3E%3D%203.17.2-blue.svg" />
    <a href="https://github.com/Nirongxu/vue-xuAdmin/blob/master/README.md">
      <img alt="Documentation" src="https://img.shields.io/badge/documentation-yes-brightgreen.svg" target="_blank" />
    </a>
    <a href="https://github.com/Nirongxu/vue-xuAdmin/blob/master/LICENSE">
      <img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-yellow.svg" target="_blank" />
    </a>
  </p>

  > pip命令：pip install CACodeFramework



  👤 **CACode**

  * Github: [@cctvadmin](https://github.com/cctvadmin)
  * QQ: 2075383131
  * wechat: cacode
  * email: cacode@163.com



  - python >=3.6
  - simplejson >= 3.17.2

  项目地址: https://gitee.com/cacode_cctvadmin/CACodeFramework-python-ORM
  项目文档：https://frame.cacode.ren

  > 统一市面上所有的数据库创建者，并分配连接池和缓存



  如果这个框架对你有帮助的话，请给个星点个star



  !['CACode Development Team'](./imgs/icon_dev.png)
  文档编辑于：2021/03/17 07:41
  作者：CACode


pkgId: 69e919a4db3150b02e0530162db693825170b06d012a6a4b9153664e8068bf73
name: python-CADET
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: CADET is an alias for CADET-Python
url: https://pypi.org/project/CADET/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CADET-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [CADET-Core](https://github.com/cadet/CADET-Core) is currently distributed via [conda-forge](https://anaconda.org/conda-forge/cadet).

  Please **remove**
  ```bash
  pip install cadet
  ```
  from your environment or dependency files and instead install [CADET-Python](https://pypi.org/project/CADET-Python/) following the instructions below. If you encounter any issues, please refer to the [CADET-Forum](https://forum.cadet-web.de/).

   




  **CADET-Python** provides a file-based Python interface for **CADET-Core**, which must be installed separately. For this, please refer to the [installation instructions](https://cadet.github.io/master/getting_started/installation.html) and the [CADET-Core repository](https://github.com/cadet/CADET-Core).

  The CADET-Python package simplifies access by mapping to the [CADET interface](https://cadet.github.io/master/interface/index.html#), **with all dataset names in lowercase**.



  To install CADET-Python, use:

  ```
  pip install cadet-python
  ```



  The package includes two primary classes:

  - **`CADET`**: The main class to configure and run simulations.
  - **`H5`**: A general-purpose HDF5 interface.



  To set a simulation parameter, such as the column porosity for column 1.

  Referring to this path in the CADET interface:
  ```
  /input/model/unit_001/COL_POROSITY
  ```
  In CADET-Python, this is now set as:
  ```
  from cadet import Cadet


  sim = Cadet()


  sim.root.input.model.unit_001.col_porosity = 0.33
  ```


  Before running, save the simulation configuration to a file:
  ```
  sim.filename = "/path/to/your/file.hdf5"
  sim.save()
  ```


  To execute the simulation, specify the path to **CADET-Core**. On Windows, set the path to `cadet-cli.exe`:
  ```
  sim.cadet_path = '/path/to/cadet-cli'
  ```


  Run the simulation and load the output data with:
  ```
  print(sim.run())
  sim.load()
  ```


  If you have a pre-simulated file, you can read it directly:
  ```

  sim = Cadet()


  sim.filename = "/path/to/your/file.hdf5"
  sim.load()
  ```
  At this point, any data in the file can be accessed.


pkgId: 779324b9728ae4501e2b2ee10b53152ec2934bbcbb876d89540d6e733264f00f
name: python-CADET-Python
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: CADET-Python is a Python interface to the CADET-Core simulator
url: https://pypi.org/project/CADET-Python/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CADET-Python-1.0.1-1.src.rpm
checksum_type: sha256
description:
  **CADET-Python** provides a file-based Python interface for **CADET-Core**, which must be installed separately. For this, please refer to the [installation instructions](https://cadet.github.io/master/getting_started/installation.html) and the [CADET-Core repository](https://github.com/cadet/CADET-Core).

  The CADET-Python package simplifies access by mapping to the [CADET interface](https://cadet.github.io/master/interface/index.html#), **with all dataset names in lowercase**.



  To install CADET-Python, use:

  ```
  pip install cadet-python
  ```



  The package includes two primary classes:

  - **`CADET`**: The main class to configure and run simulations.
  - **`H5`**: A general-purpose HDF5 interface.



  To set a simulation parameter, such as the column porosity for column 1.

  Referring to this path in the CADET interface:
  ```
  /input/model/unit_001/COL_POROSITY
  ```
  In CADET-Python, this is now set as:
  ```
  from cadet import Cadet


  sim = Cadet()


  sim.root.input.model.unit_001.col_porosity = 0.33
  ```


  Before running, save the simulation configuration to a file:
  ```
  sim.filename = "/path/to/your/file.hdf5"
  sim.save()
  ```


  To execute the simulation, specify the path to **CADET-Core**. On Windows, set the path to `cadet-cli.exe`:
  ```
  sim.cadet_path = '/path/to/cadet-cli'
  ```


  Run the simulation and load the output data with:
  ```
  print(sim.run())
  sim.load()
  ```


  If you have a pre-simulated file, you can read it directly:
  ```

  sim = Cadet()


  sim.filename = "/path/to/your/file.hdf5"
  sim.load()
  ```
  At this point, any data in the file can be accessed.


pkgId: 9f822ed42fb5d565f1435aea2f82346db2fe893d310030b177ce82f5b9cee7d1
name: python-CADET-RDM
arch: src
version: 0.0.41
epoch: 0
release: 1
summary: A Python toolbox for research data management.
url: https://pypi.org/project/CADET-RDM/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CADET-RDM-0.0.41-1.src.rpm
checksum_type: sha256
description:
  Welcome to CADET-RDM, a project by the Forschungszentrum Jülich.

  This tool aims to help track and version control:
  - input data
  - code
  - software versions
  - output data

  and allow for easy sharing, integration, and reproduction of generated results.



  You can read the documentation [here](https://cadet-rdm.readthedocs.io).


pkgId: b0986aa05f177dc85f7eeffae23cc9c0ccdcbd7103f5663547227b8f3f26e0fb
name: python-CADETMatch
arch: src
version: 0.8.16
epoch: 0
release: 1
summary: CADETMatch is a parameter estimation and error modeling library for CADET
url: https://github.com/modsim/CADET-Match
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CADETMatch-0.8.16-1.src.rpm
checksum_type: sha256
description:
  CADET Parameter estimation engine

  This software is a work in progress. The file formats will break as changes as made.

  This software is designed to do parameter estimation for CADET. The required libraries are in the README.txt file
  in the CADETMatch directory.

  The documentation is also a work in progress.

  If you use this software in your research please give credit.


pkgId: 8f00ce723ddfb75f365291a672932f4c851793e4e4bb6f8e0b28e7c1eb99fa30
name: python-CAMSA
arch: src
version: 1.3
epoch: 0
release: 1
summary: CAMSA: a tool for Comparative Analysis and Merging of Scaffold Assemblies
url: https://github.com/compbiol/camsa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CAMSA-1.3-1.src.rpm
checksum_type: sha256
description:
  For full description and instructions please refer to the `Github repository`_ and the corresponding `CAMSA wiki`_.

  .. _Github repository: https://github.com/aganezov/camsa
  .. _CAMSA wiki: https://github.com/aganezov/camsa/wiki


pkgId: 2ba22b525880fb87829637ad0397d547339db0349035162f35f6a13989795db3
name: python-CASSIA
arch: src
version: 0.1.6
epoch: 0
release: 1
url: https://github.com/elliotxe/CASSIA
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CASSIA-0.1.6-1.src.rpm
checksum_type: sha256
summary:
  CASSIA (Cell type Annotation using Specialized System with Integrated AI) is a Python package for automated cell type annotation in single-cell RNA sequencing data using large language models.

description:
  CASSIA (Cell type Annotation using Specialized System with Integrated AI) is a Python package for automated cell type annotation in single-cell RNA sequencing data using large language models.



  - Automated cell type annotation using multiple LLM providers (OpenAI, Anthropic, OpenRouter)
  - Support for batch processing of multiple clusters
  - Variance analysis for annotation reliability
  - Detailed HTML report generation
  - Score-based annotation quality assessment
  - Support for marker gene validation
  - Interactive analysis with step-by-step reasoning



  ```bash
  pip install CASSIA
  ```



  ```python
  import CASSIA


  CASSIA.set_api_key("your-openai-key", provider="openai")
  CASSIA.set_api_key("your-anthropic-key", provider="anthropic")
  CASSIA.set_api_key("your-openrouter-key", provider="openrouter")


  result = CASSIA.run_cell_type_analysis_wrapper(
      model="gpt-4",
      temperature=0,
      marker_list=["CD3D", "CD4", "IL7R"],
      tissue="PBMC",
      species="human",
      provider="openai"
  )


  results = CASSIA.run_cell_type_analysis_batchrun(
      marker="path/to/marker_file.csv",
      output_name="results.json",
      model="gpt-4",
      tissue="PBMC",
      species="human"
  )
  ```



  CASSIA accepts marker genes in several formats:
  - CSV files with cluster and marker columns
  - Pandas DataFrames
  - Direct lists of marker genes
  - Seurat or Scanpy differential expression results




  - `run_cell_type_analysis_wrapper()`: Single cluster analysis with support for multiple LLM providers
  - `run_cell_type_analysis_batchrun()`: Batch analysis of multiple clusters
  - `run_analysis_n_times()`: Multiple runs for consensus analysis


  - `process_cell_type_variance_analysis_batch()`: Analyze annotation variance
  - `score_annotation_batch()`: Score annotation quality
  - `generate_cell_type_analysis_report_wrapper()`: Generate detailed HTML reports


  - `set_api_key()`: Set API keys for different providers
  - `get_top_markers()`: Extract top markers from differential expression results
  - `split_markers()`: Process marker lists into standardized format




  ```python

  result, conversation = CASSIA.run_cell_type_analysis_wrapper(
      model="gpt-4",
      temperature=0,
      marker_list=["CD3D", "CD4", "IL7R", "FOXP3"],
      tissue="PBMC",
      species="human",
      provider="openai"
  )


  print(result["main_cell_type"])
  ```


  ```python

  CASSIA.run_batch_analysis_n_times(
      n=3,  # Number of iterations
      marker="markers.csv",
      output_name="batch_results",
      model="gpt-4",
      tissue="lung",
      species="human",
      max_workers=10
  )
  ```


  ```python
  CASSIA.generate_cell_type_analysis_report_wrapper(
      full_result_path="results.csv",
      marker="markers.csv",
      cluster_name="cluster_1",
      major_cluster_info="Human PBMC",
      output_name="analysis_report.html",
      model="gpt-4",
      provider="openai"
  )
  ```



  Current Version: 0.1.0 (Alpha)



  1. âœ… Core functionality implementation
  2. âœ… Multiple LLM provider support
  3. âœ… Report generation
  4. ðŸ”„ Marker grouping (In Progress)
  5. ðŸ“‹ Python package distribution
  6. ðŸ“‹ R package development
  7. ðŸ“‹ Subcluster functionality
  8. âœ… Web UI implementation



  We welcome contributions! Please feel free to submit pull requests or open issues on our GitHub repository.



  This project is licensed under the MIT License.



  If you use CASSIA in your research, please cite:

  ```bibtex
  @software{CASSIA2024,
    author = {Xie, Elliot Yixuan},
    title = {CASSIA: Cell type Annotation using Specialized System with Integrated AI},
    year = {2024},
    publisher = {GitHub},
    url = {https://github.com/elliotxe/CASSIA}
  }
  ```



  For support, please open an issue on our [GitHub repository](https://github.com/elliotxe/CASSIA/issues).


pkgId: aca140c7524ee8eb85237f006905055b60233046b65b9d3c156f67c2dbbd36f4
name: python-CASSIA
arch: src
version: 0.1.9
epoch: 0
release: 1
url: https://github.com/elliotxe/CASSIA
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CASSIA-0.1.9-1.src.rpm
checksum_type: sha256
summary:
  CASSIA (Cell type Annotation using Specialized System with Integrated AI) is a Python package for automated cell type annotation in single-cell RNA sequencing data using large language models.

description:
  CASSIA (Cell type Annotation using Specialized System with Integrated AI) is a Python package for automated cell type annotation in single-cell RNA sequencing data using large language models.



  - Automated cell type annotation using multiple LLM providers (OpenAI, Anthropic, OpenRouter)
  - Support for batch processing of multiple clusters
  - Variance analysis for annotation reliability
  - Detailed HTML report generation
  - Score-based annotation quality assessment
  - Support for marker gene validation
  - Interactive analysis with step-by-step reasoning





  ```bash


  pip install pandas openai requests numpy anthropic


  pip install CASSIA
  pip install CASSIA_rag  # optional for the RAG agent
  ```



  ```python
  import CASSIA


  CASSIA.set_api_key("your-openai-key", provider="openai")
  CASSIA.set_api_key("your-anthropic-key", provider="anthropic")
  CASSIA.set_api_key("your-openrouter-key", provider="openrouter")


  result = CASSIA.run_cell_type_analysis_wrapper(
      model="gpt-4",
      temperature=0,
      marker_list=["CD3D", "CD4", "IL7R"],
      tissue="PBMC",
      species="human",
      provider="openai"
  )


  results = CASSIA.run_cell_type_analysis_batchrun(
      marker="path/to/marker_file.csv",
      output_name="results.json",
      model="gpt-4",
      tissue="PBMC",
      species="human"
  )
  ```



  CASSIA accepts marker genes in several formats:
  - CSV files with cluster and marker columns
  - Pandas DataFrames
  - Direct lists of marker genes
  - Seurat or Scanpy differential expression results




  - `run_cell_type_analysis_wrapper()`: Single cluster analysis with support for multiple LLM providers
  - `run_cell_type_analysis_batchrun()`: Batch analysis of multiple clusters
  - `run_analysis_n_times()`: Multiple runs for consensus analysis


  - `process_cell_type_variance_analysis_batch()`: Analyze annotation variance
  - `score_annotation_batch()`: Score annotation quality
  - `generate_cell_type_analysis_report_wrapper()`: Generate detailed HTML reports


  - `set_api_key()`: Set API keys for different providers
  - `get_top_markers()`: Extract top markers from differential expression results
  - `split_markers()`: Process marker lists into standardized format




  ```python

  result, conversation = CASSIA.run_cell_type_analysis_wrapper(
      model="gpt-4",
      temperature=0,
      marker_list=["CD3D", "CD4", "IL7R", "FOXP3"],
      tissue="PBMC",
      species="human",
      provider="openai"
  )


  print(result["main_cell_type"])
  ```


  ```python

  CASSIA.run_batch_analysis_n_times(
      n=3,  # Number of iterations
      marker="markers.csv",
      output_name="batch_results",
      model="gpt-4",
      tissue="lung",
      species="human",
      max_workers=10
  )
  ```


  ```python
  CASSIA.generate_cell_type_analysis_report_wrapper(
      full_result_path="results.csv",
      marker="markers.csv",
      cluster_name="cluster_1",
      major_cluster_info="Human PBMC",
      output_name="analysis_report.html",
      model="gpt-4",
      provider="openai"
  )
  ```



  We welcome contributions! Please feel free to submit pull requests or open issues on our GitHub repository.



  This project is licensed under the MIT License.



  For support, please open an issue on our [GitHub repository](https://github.com/elliotxe/CASSIA/issues).


pkgId: dcb560c224ed6ac016fbc79b34091317749236454814e862ab3272714d95e74d
name: python-CBBpy
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A Python-based web scraper for NCAA basketball.
url: https://github.com/dcstats/CBBpy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CBBpy-2.0.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Version](https://img.shields.io/pypi/v/cbbpy.svg)](https://pypi.org/project/cbbpy/) [![Downloads](https://img.shields.io/pypi/dm/cbbpy?color=be94e4
  )](https://pypistats.org/packages/cbbpy)




  This package is designed to bridge the gap between data and analysis for NCAA D1 basketball. CBBpy can grab play-by-play, boxscore, and other game metadata for any NCAA D1 men's or women's basketball game. Inspired by the [ncaahoopR package](https://github.com/lbenz730/ncaahoopR) by Luke Benz - check that out if you are an R user!


  CBBpy requires Python >= 3.9 as well as the following packages:
  * pandas>=1.4.2
  * numpy>=1.22.3
  * python-dateutil>=2.8.2
  * pytz>=2022.1
  * tqdm>=4.63.0
  * lxml>=4.9.0
  * joblib>=1.1.0
  * bs4>=0.0.1
  * requests>=2.27.0


  Install using pip:
  ```
  pip install cbbpy
  ```

  The men's and women's scrapers can be imported as such:
  ```
  import cbbpy.mens_scraper as s
  import cbbpy.womens_scraper as s
  ```


  NOTE: game ID, as far as CBBpy is concernced, is a valid **ESPN** game ID

  `s.get_game_info(game_id: str)` grabs all the metadata (game date, time, score, teams, referees, etc) for a particular game.

  `s.get_game_boxscore(game_id: str)` returns a pandas DataFrame with each player's stats for a particular game.

  `s.get_game_pbp(game_id: str)` scrapes the play-by-play tables for a game and returns a pandas DataFrame, with each entry representing a play made during the game.

  `s.get_game(game_id: str, info: bool = True, box: bool = True, pbp: bool = True)` gets *all* information about a game (game info, boxscore, PBP) and returns a tuple of results `(game_info, boxscore, pbp)`. `info, box, pbp` are booleans which users can set to `False` if there is any information they wish not to scrape. For example, `box = False` would return an empty DataFrame for the boxscore info, while scraping PBP and metadata info normally.

  `s.get_games_season(season: int, info: bool = True, box: bool = True, pbp: bool = True)` scrapes all game information for all games in a particular season. As an example, to scrape games for the 2020-21 season, call `get_games_season(2021)`. Returns a tuple of 3 DataFrames, similar to `get_game`. See `get_game` for an explanation of booleans `info, box, pbp`.

  `s.get_games_range(start_date: str, end_date: str, info: bool = True, box: bool = True, pbp: bool = True)` scrapes all game information for all games between `start_date` and `end_date` (inclusive). As an example, to scrape games between November 30, 2022 and December 10, 2022, call `get_games_season('11-30-2022', '12-10-2022')`. Returns a tuple of 3 DataFrames, similar to `get_game`. See `get_game` for an explanation of booleans `info, box, pbp`.

  `s.get_game_ids(date: Union[str, datetime])` returns a list of all game IDs for a particular date.



  Function call:

  ```
  import cbbpy.mens_scraper as s
  s.get_game_info('401522202')
  ```

  Returns:
  |    |   game_id | home_team     |   home_id |   home_rank | home_record   |   home_score | away_team              |   away_id |   away_rank | away_record   |   away_score | home_win   |   num_ots | is_conference   | is_neutral   | is_postseason   | tournament                                            | game_day       | game_time    | game_loc    | arena       |   arena_capacity |   attendance | tv_network   | referee_1   | referee_2     | referee_3    |
  |---:|----------:|:--------------|----------:|------------:|:--------------|-------------:|:-----------------------|----------:|------------:|:--------------|-------------:|:-----------|----------:|:----------------|:-------------|:----------------|:------------------------------------------------------|:---------------|:-------------|:------------|:------------|-----------------:|-------------:|:-------------|:------------|:--------------|:-------------|
  |  0 | 401522202 | UConn Huskies |        41 |           4 | 31-8          |           76 | San Diego State Aztecs |        21 |           5 | 32-7          |           59 | True       |         0 | False           | True         | True            | Men's Basketball Championship - National Championship | April 03, 2023 | 06:20 PM PDT | Houston, TX | NRG Stadium |                0 |        72423 | CBS          | Ron Groover | Terry Oglesby | Keith Kimble |

  Function call:

  ```
  import cbbpy.womens_scraper as s
  s.get_game_boxscore('401528028')
  ```

  Returns (partially):
  |    |   game_id | team       | player      |   player_id | position   | starter   |   min |   fgm |   fga |   2pm |   2pa |   3pm |   3pa |   ftm |   fta |   oreb |   dreb |   reb |   ast |   stl |   blk |   to |   pf |   pts |
  |---:|----------:|:-----------|:------------|------------:|:-----------|:----------|------:|------:|------:|------:|------:|------:|------:|------:|------:|-------:|-------:|------:|------:|------:|------:|-----:|-----:|------:|
  |  0 | 401528028 | LSU Tigers | A. Reese    |     4433402 | F          | True      |    29 |     5 |    12 |     5 |    12 |     0 |     0 |     5 |     8 |      6 |      4 |    10 |     5 |     3 |     1 |    0 |    3 |    15 |
  |  1 | 401528028 | LSU Tigers | L. Williams |     4280886 | F          | True      |    37 |     9 |    16 |     9 |    16 |     0 |     0 |     2 |     2 |      1 |      4 |     5 |     0 |     3 |     0 |    3 |    4 |    20 |
  |  2 | 401528028 | LSU Tigers | F. Johnson  |     4698736 | G          | True      |    37 |     4 |    11 |     3 |     7 |     1 |     4 |     1 |     1 |      2 |      5 |     7 |     4 |     1 |     0 |    4 |    1 |    10 |
  |  3 | 401528028 | LSU Tigers | K. Poole    |     4433418 | G          | True      |    24 |     2 |     3 |     0 |     1 |     2 |     2 |     0 |     2 |      0 |      3 |     3 |     1 |     0 |     1 |    1 |    2 |     6 |
  |  4 | 401528028 | LSU Tigers | A. Morris   |     4281251 | G          | True      |    33 |     8 |    14 |     7 |    11 |     1 |     3 |     4 |     4 |      1 |      1 |     2 |     9 |     1 |     0 |    2 |    3 |    21 |

  Function call:

  ```
  import cbbpy.mens_scraper as s
  s.get_game_pbp('401522202')
  ```

  Returns (partially):
  |    |   game_id | home_team     | away_team              | play_desc                                                             |   home_score |   away_score |   half |   secs_left_half |   secs_left_reg | play_team              | play_type          | shooting_play   | scoring_play   | is_three   | shooter          | is_assisted   | assist_player   |   shot_x |   shot_y |
  |---:|----------:|:--------------|:-----------------------|:----------------------------------------------------------------------|-------------:|-------------:|-------:|-----------------:|----------------:|:-----------------------|:-------------------|:----------------|:---------------|:-----------|:-----------------|:--------------|:----------------|---------:|---------:|
  |  0 | 401522202 | UConn Huskies | San Diego State Aztecs | Jump Ball won by UConn                                                |            0 |            0 |      1 |             1200 |            2400 | UConn Huskies          | jump ball          | False           | False          | False      |                  | False         |                 |      nan |      nan |
  |  1 | 401522202 | UConn Huskies | San Diego State Aztecs | Jordan Hawkins made Jumper. Assisted by Adama Sanogo.                 |            2 |            0 |      1 |             1174 |            2374 | UConn Huskies          | jumper             | True            | True           | False      | Jordan Hawkins   | True          | Adama Sanogo    |       18 |       15 |
  |  2 | 401522202 | UConn Huskies | San Diego State Aztecs | Lamont Butler made Three Point Jumper. Assisted by Matt Bradley.      |            2 |            3 |      1 |             1152 |            2352 | San Diego State Aztecs | three point jumper | True            | True           | True       | Lamont Butler    | True          | Matt Bradley    |       39 |       22 |
  |  3 | 401522202 | UConn Huskies | San Diego State Aztecs | Tristen Newton Turnover.                                              |            2 |            3 |      1 |             1130 |            2330 | UConn Huskies          | turnover           | False           | False          | False      |                  | False         |                 |      nan |      nan |
  |  4 | 401522202 | UConn Huskies | San Diego State Aztecs | Darrion Trammell made Three Point Jumper. Assisted by Keshad Johnson. |            2 |            6 |      1 |             1108 |            2308 | San Diego State Aztecs | three point jumper | True            | True           | True       | Darrion Trammell | True          | Keshad Johnson  |        1 |        0 |


  Feel free to reach out to me directly with any questions, requests, or suggestions at <dnlcowan37@gmail.com>.

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


pkgId: 5db9706c6e718ea30c6ecb96dc748cf7874a3ea3ade45f6b3fb77906983d85b9
name: python-CBBpy
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: A Python-based web scraper for NCAA basketball.
url: https://github.com/dcstats/CBBpy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CBBpy-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Version](https://img.shields.io/pypi/v/cbbpy.svg)](https://pypi.org/project/cbbpy/) [![Downloads](https://img.shields.io/pypi/dm/cbbpy?color=be94e4
  )](https://pypistats.org/packages/cbbpy)




  This package is designed to bridge the gap between data and analysis for NCAA D1 basketball. CBBpy can grab play-by-play, boxscore, and other game metadata for any NCAA D1 men's or women's basketball game. Inspired by the [ncaahoopR package](https://github.com/lbenz730/ncaahoopR) by Luke Benz - check that out if you are an R user!


  CBBpy requires Python >= 3.9 as well as the following packages:
  * pandas>=2.0.0
  * numpy>=2.0.0
  * python-dateutil>=2.4.0
  * pytz>=2022.1
  * tqdm>=4.63.0
  * lxml>=4.9.0
  * joblib>=1.0.0
  * beautifulsoup4>=4.11.0
  * requests>=2.27.0
  * rapidfuzz>=3.9.0
  * platformdirs>=4.0.0


  Install using pip:
  ```shell
  pip install cbbpy
  ```

  Or upgrade an existing installation:
  ```shell
  pip install --upgrade cbbpy
  ```

  The men's and women's scrapers can be imported as such:
  ```python
  import cbbpy.mens_scraper as s
  import cbbpy.womens_scraper as s
  ```


  NOTE: game ID, as far as CBBpy is concerned, is a valid **ESPN** game ID

  `s.get_game_info(game_id: Union[str, int])` grabs all the metadata (game date, time, score, teams, referees, etc) for a particular game.

  `s.get_game_boxscore(game_id: Union[str, int])` returns a pandas DataFrame with each player's stats for a particular game.

  `s.get_game_pbp(game_id: Union[str, int])` scrapes the play-by-play tables for a game and returns a pandas DataFrame, with each entry representing a play made during the game.

  `s.get_game(game_id: Union[str, int], info: bool = True, box: bool = True, pbp: bool = True)` gets *all* information about a game (game info, boxscore, PBP) and returns a tuple of results `(game_info, boxscore, pbp)`. `info, box, pbp` are booleans which users can set to `False` if there is any information they wish not to scrape. For example, `box = False` would return an empty DataFrame for the boxscore info, while scraping PBP and metadata info normally.

  `s.get_games_season(season: Union[str, int] = None, info: bool = True, box: bool = True, pbp: bool = True)` scrapes all game information for all finished or in progress games in a particular season (defaults to the current season). As an example, to scrape games for the 2020-21 season, call `get_games_season(2021)`. Returns a tuple of 3 DataFrames, similar to `get_game`. See `get_game` for an explanation of booleans `info, box, pbp`.

  `s.get_games_range(start_date: Union[int, datetime], end_date: Union[int, datetime], info: bool = True, box: bool = True, pbp: bool = True)` scrapes all game information for all finished or in progress games between `start_date` and `end_date` (inclusive). As an example, to scrape games from November 30, 2022 to December 10, 2022, call `get_games_season('11-30-2022', '12-10-2022')`. Returns a tuple of 3 DataFrames, similar to `get_game`. See `get_game` for an explanation of booleans `info, box, pbp`.

  `s.get_games_team(team: str, season: Union[str, int] = None, info: bool = True, box: bool = True, pbp: bool = True)` scrapes all game information for all finished or in progress games in a particular season (defaults to the current season) for a given team. As an example, to scrape games for Duke's 2020-21 season, call `get_games_team('duke', 2021)`; for their current season, you can just call `get_games_team('duke')`. If a given team does not have an exact match in the static list of teams scraped from ESPN's site, this function will scrape the games for the closest fuzzy-matched team (e.g. if "valpo" is provided as the team, the function will scrape the games for "Valparaiso"). Returns a tuple of 3 DataFrames, similar to `get_game`. See `get_game` for an explanation of booleans `info, box, pbp`.

  `s.get_games_conference(conference: str, season: Union[str, int] = None, info: bool = True, box: bool = True, pbp: bool = True)` scrapes all game information for all finished or in progress games in a particular season (defaults to the current season) for all teams in a given conference. As an example, to scrape games for the A10's 2017-18 season, call `get_games_conference('a10', 2018)`; for their current season, you can just call `get_games_conference('a10')`. If a given conference does not have an exact match in the static list of conferences scraped from ESPN's site, this function will scrape the games for the closest fuzzy-matched conference (e.g. if "am east" is provided as the conference, the function will scrape the games for "America East Conference"). Returns a tuple of 3 DataFrames, similar to `get_game`. See `get_game` for an explanation of booleans `info, box, pbp`.

  `s.get_game_ids(date: Union[str, datetime])` returns a list of all game IDs for a particular date.

  `s.get_player_info(player_id: Union[str, int])` returns a DataFrame describing the player's info from ESPN's bio page.

  `s.get_teams_from_conference(conference: str, season: Union[str, int] = None)` returns a list of the teams in the given conference for a season (defaults to the current season).

  `s.get_team_schedule(team: str, season: Union[str, int] = None)` returns a DataFrame of a team's schedule for a given season (defaults to the current season). If a given team does not have an exact match in the static list of teams scraped from ESPN's site, this function will scrape the schedule for the closest fuzzy-matched team (e.g. if "valpo" is provided as the team, the function will scrape the schedule for "Valparaiso").

  `s.get_conference_schedule(conference: str, season: Union[str, int] = None)` returns a DataFrame of the schedules for all teams in a given conference for a given season (defaults to the current season). If a given conference does not have an exact match in the static list of conferences scraped from ESPN's site, this function will scrape the schedules for the closest fuzzy-matched conference (e.g. if "am east" is provided as the conference, the function will scrape the schedules for "America East Conference").



  Function call:

  ```python
  import cbbpy.mens_scraper as s
  s.get_game_info('401522202')
  ```

  Returns:
  |    |   game_id | home_team     |   home_id |   home_rank | home_record   |   home_score | away_team              |   away_id |   away_rank | away_record   |   away_score | home_win   |   num_ots | is_conference   | is_neutral   | is_postseason   | tournament                                            | game_day       | game_time    | game_loc    | arena       |   arena_capacity |   attendance | tv_network   | referee_1   | referee_2     | referee_3    |
  |---:|----------:|:--------------|----------:|------------:|:--------------|-------------:|:-----------------------|----------:|------------:|:--------------|-------------:|:-----------|----------:|:----------------|:-------------|:----------------|:------------------------------------------------------|:---------------|:-------------|:------------|:------------|-----------------:|-------------:|:-------------|:------------|:--------------|:-------------|
  |  0 | 401522202 | UConn Huskies |        41 |           4 | 31-8          |           76 | San Diego State Aztecs |        21 |           5 | 32-7          |           59 | True       |         0 | False           | True         | True            | Men's Basketball Championship - National Championship | April 03, 2023 | 06:20 PM PDT | Houston, TX | NRG Stadium |                0 |        72423 | CBS          | Ron Groover | Terry Oglesby | Keith Kimble |

  Function call:

  ```python
  import cbbpy.womens_scraper as s
  s.get_game_boxscore('401528028')
  ```

  Returns (partially):
  |    |   game_id | team       | player      |   player_id | position   | starter   |   min |   fgm |   fga |   2pm |   2pa |   3pm |   3pa |   ftm |   fta |   oreb |   dreb |   reb |   ast |   stl |   blk |   to |   pf |   pts |
  |---:|----------:|:-----------|:------------|------------:|:-----------|:----------|------:|------:|------:|------:|------:|------:|------:|------:|------:|-------:|-------:|------:|------:|------:|------:|-----:|-----:|------:|
  |  0 | 401528028 | LSU Tigers | A. Reese    |     4433402 | F          | True      |    29 |     5 |    12 |     5 |    12 |     0 |     0 |     5 |     8 |      6 |      4 |    10 |     5 |     3 |     1 |    0 |    3 |    15 |
  |  1 | 401528028 | LSU Tigers | L. Williams |     4280886 | F          | True      |    37 |     9 |    16 |     9 |    16 |     0 |     0 |     2 |     2 |      1 |      4 |     5 |     0 |     3 |     0 |    3 |    4 |    20 |
  |  2 | 401528028 | LSU Tigers | F. Johnson  |     4698736 | G          | True      |    37 |     4 |    11 |     3 |     7 |     1 |     4 |     1 |     1 |      2 |      5 |     7 |     4 |     1 |     0 |    4 |    1 |    10 |
  |  3 | 401528028 | LSU Tigers | K. Poole    |     4433418 | G          | True      |    24 |     2 |     3 |     0 |     1 |     2 |     2 |     0 |     2 |      0 |      3 |     3 |     1 |     0 |     1 |    1 |    2 |     6 |
  |  4 | 401528028 | LSU Tigers | A. Morris   |     4281251 | G          | True      |    33 |     8 |    14 |     7 |    11 |     1 |     3 |     4 |     4 |      1 |      1 |     2 |     9 |     1 |     0 |    2 |    3 |    21 |

  Function call:

  ```python
  import cbbpy.mens_scraper as s
  s.get_game_pbp('401522202')
  ```

  Returns (partially):
  |    |   game_id | home_team     | away_team              | play_desc                                                             |   home_score |   away_score |   half |   secs_left_half |   secs_left_reg | play_team              | play_type          | shooting_play   | scoring_play   | is_three   | shooter          | is_assisted   | assist_player   |   shot_x |   shot_y |
  |---:|----------:|:--------------|:-----------------------|:----------------------------------------------------------------------|-------------:|-------------:|-------:|-----------------:|----------------:|:-----------------------|:-------------------|:----------------|:---------------|:-----------|:-----------------|:--------------|:----------------|---------:|---------:|
  |  0 | 401522202 | UConn Huskies | San Diego State Aztecs | Jump Ball won by UConn                                                |            0 |            0 |      1 |             1200 |            2400 | UConn Huskies          | jump ball          | False           | False          | False      |                  | False         |                 |      nan |      nan |
  |  1 | 401522202 | UConn Huskies | San Diego State Aztecs | Jordan Hawkins made Jumper. Assisted by Adama Sanogo.                 |            2 |            0 |      1 |             1174 |            2374 | UConn Huskies          | jumper             | True            | True           | False      | Jordan Hawkins   | True          | Adama Sanogo    |       18 |       15 |
  |  2 | 401522202 | UConn Huskies | San Diego State Aztecs | Lamont Butler made Three Point Jumper. Assisted by Matt Bradley.      |            2 |            3 |      1 |             1152 |            2352 | San Diego State Aztecs | three point jumper | True            | True           | True       | Lamont Butler    | True          | Matt Bradley    |       39 |       22 |
  |  3 | 401522202 | UConn Huskies | San Diego State Aztecs | Tristen Newton Turnover.                                              |            2 |            3 |      1 |             1130 |            2330 | UConn Huskies          | turnover           | False           | False          | False      |                  | False         |                 |      nan |      nan |
  |  4 | 401522202 | UConn Huskies | San Diego State Aztecs | Darrion Trammell made Three Point Jumper. Assisted by Keshad Johnson. |            2 |            6 |      1 |             1108 |            2308 | San Diego State Aztecs | three point jumper | True            | True           | True       | Darrion Trammell | True          | Keshad Johnson  |        1 |        0 |

  Function call:

  ```python
  import cbbpy.mens_scraper as s
  s.get_player_info('5105865')
  ```

  Returns:
  |    |   player_id | first_name   | last_name   |   jersey_number | pos     | status   | team              | experience   | height   | weight   | birthplace   | date_of_birth   |
  |---:|------------:|:-------------|:------------|----------------:|:--------|:---------|:------------------|:-------------|:---------|:---------|:-------------|:----------------|
  |  0 |     5105865 | Reed         | Bailey      |               1 | Forward | active   | Davidson Wildcats | Junior       | 6' 10"   | 230 lbs  | Harvard, MA  |                 |

  Function call:

  ```python
  import cbbpy.womens_scraper as s
  s.get_team_schedule('davidson', 2022)
  ```

  Returns (partially):
  |    | team     |   team_id |   season |   game_id | game_day          | game_time    | opponent                                  |   opponent_id | season_type    | game_status   | tv_network   | game_result   |
  |---:|:---------|----------:|---------:|----------:|:------------------|:-------------|:------------------------------------------|--------------:|:---------------|:--------------|:-------------|:--------------|
  |  0 | Davidson |      2166 |     2022 | 401370995 | November 09, 2021 | 04:00 PM PST | Delaware Blue Hens                        |            48 | Regular Season | Final         | ESPN+        | W 93-71       |
  |  1 | Davidson |      2166 |     2022 | 401370996 | November 13, 2021 | 05:30 PM PST | San Francisco Dons                        |          2539 | Regular Season | Final         |              | L 60-65       |
  |  2 | Davidson |      2166 |     2022 | 401365883 | November 18, 2021 | 09:00 AM PST | New Mexico State Aggies                   |           166 | Regular Season | Final         | ESPNU        | L 64-75       |
  |  3 | Davidson |      2166 |     2022 | 401377036 | November 19, 2021 | 11:30 AM PST | Pennsylvania Quakers                      |           219 | Regular Season | Final         | ESPNU        | W 72-60       |
  |  4 | Davidson |      2166 |     2022 | 401377040 | November 21, 2021 | 03:00 PM PST | East Carolina Pirates                     |           151 | Regular Season | Final         | ESPNU        | W 76-67       |

  Function call:

  ```python
  import cbbpy.mens_scraper as s
  s.get_conference_schedule('ovc', 2015)
  ```

  Returns (showing the middle of the output):
  |    | team             |   team_id |   season |   game_id | game_day          | game_time    | opponent                   |   opponent_id | season_type    | game_status   | tv_network   | game_result   |
  |---:|:-----------------|----------:|---------:|----------:|:------------------|:-------------|:---------------------------|--------------:|:---------------|:--------------|:-------------|:--------------|
  | 30 | Belmont          |      2057 |     2015 | 400766521 | March 06, 2015    | 07:15 PM PST | Eastern Kentucky Colonels  |          2198 | Regular Season | Final         | ESPNU        | W 53-52       |
  | 31 | Belmont          |      2057 |     2015 | 400766705 | March 07, 2015    | 04:00 PM PST | Murray State Racers        |            93 | Regular Season | Final         | ESPN2        | W 88-87       |
  | 32 | Belmont          |      2057 |     2015 | 400785349 | March 20, 2015    | 12:30 PM PDT | Virginia Cavaliers         |           258 | Postseason     | Final         | truTV        | L 67-79       |
  | 33 | Eastern Kentucky |      2198 |     2015 | 400596308 | November 14, 2014 | 04:00 PM PST | Savannah State Tigers      |          2542 | Regular Season | Final         |              | W 76-53       |
  | 34 | Eastern Kentucky |      2198 |     2015 | 400596315 | November 18, 2014 | 04:00 PM PST | Kentucky Christian Knights |          3077 | Regular Season | Final         |              | W 115-35      |




  Feel free to reach out to me directly with any questions, requests, or suggestions at <dnlcowan37@gmail.com>.

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


pkgId: 53ad292beeca8e1f33cebef9dad3f33dbe6132749a2a96920d938dcb910c51db
name: python-CBSE-Results-Scraper
arch: src
version: 1.2.9
epoch: 0
release: 1
url: https://github.com/AVS1508/CBSE-Results-Scraper
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CBSE-Results-Scraper-1.2.9-1.src.rpm
checksum_type: sha256
summary:
  CBSE-Results-Scraper is a command-line Python application that scrapes and downloads student reports of CBSE (Central Board of Secondary Education) Class XII Results 2019 from http://cbseresults.nic.in.


pkgId: e7103fe5f0394e09b8eef67937c8b7a80643eb2b5b2338f35aa4cb6fddeadbe8
name: python-CCAgT-utils
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A framework of utilities to help at the use of the CCAgT dataset
url: https://github.com/johnnv1/CCAgT_dataset_utils
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CCAgT-utils-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/CCAgT-utils?color=blue&label=pypi%20version)](https://pypi.org/project/CCAgT-utils/)
  [![Code coverage Status](https://codecov.io/gh/johnnv1/CCAgT-utils/branch/main/graph/badge.svg?token=HB8P4BKTZ7)](https://codecov.io/gh/johnnv1/CCAgT-utils)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/johnnv1/CCAgT-utils/main.svg)](https://results.pre-commit.ci/latest/github/johnnv1/CCAgT-utils/main)
  [![main status](https://github.com/johnnv1/CCAgT-utils/actions/workflows/main.yml/badge.svg)](https://github.com/johnnv1/CCAgT-utils/actions/workflows/main.yml)
  [![DOI](https://zenodo.org/badge/456516174.svg)](https://zenodo.org/badge/latestdoi/456516174)



  CCAgT-utils it's a package to work with the **CCAgT dataset**:
  `Images of Cervical Cells with AgNOR Stain Technique`. The
  package will provide some customized codes for annotations
  format conversion, mask generation, plotting samples, etc.



  I have been working with images of cervical cells stained
  with AgNOR since January/2020 for my master thesis. The
  results of my thesis you can find at [CCAgT-benchmarks](https://github.com/johnnv1/CCAgT-benchmarks).
  In general, the objective of the thesis it's automatize the
  principal part to help at the diagnostic/prognostic of these
   cells. Therefore, I also have developed some codes to
   preprocess or just to help in the use of this dataset.


  These codes to work with the dataset will be available at this
  package.



  1. [Links to download the dataset](#links-to-download-the-ccagt-dataset)
  2. [What does this dataset look like?](#what-does-this-dataset-look-like)
  3. [Examples of use of this package](#examples-of-use)




  1. Version 1.1 - [drive](https://drive.google.com/drive/folders/1TBpYCv6S1ydASLauSzcsvO7Wc5O-WUw0?usp=sharing) or [UFSC repository](https://arquivos.ufsc.br/d/373be2177a33426a9e6c/)
  2. Version 2 - [Mendeley data](https://doi.org/10.17632/wg4bpm33hj.2)



  The [Hugging Face datasets API](https://github.com/huggingface/datasets) provides a easily way to download and use various datasets. One of these datasets is CCAgT dataset, which can be found at [huggingface.co/datasets/lapix/CCAgT/](https://huggingface.co/datasets/lapix/CCAgT/).

  ```python
  from datasets import load_dataset

  dataset = load_dataset("lapix/CCAgT")


  ```


  Explanations and examples around the `>=2.0` version of the
  dataset. If you want to use older versions of the dataset,
  you will need to make some modifications to the data directory
  organizations, or things like that.


  This is a computer vision dataset, created by some collaborators
  from different departments at [Universidade Federal de Santa Catarina (UFSC)](https://en.ufsc.br/).
  The dataset contains images annotated/labelled for semantic
  segmentation and others. The annotation tool is [labelbox](https://labelbox.com/).
  In the data repositories will the images, masks (semantic
  segmentation) and COCO annotations for object detection. The
  codes to convert annotations from labelbox format to others
  will be in this package.

  Each slide can have some differences in the stain coloration,
  at figure 1 can be seen an image created from different images
  of different slides.

  ![Image sample created from samples from different slides](./data/static_images/Figure1.jpg)

  In directory [./data/samples/images/](./data/samples/images/)
  can be seen the original images of each tile from different
  slides/patients. The dataset present a wide variety of colors,
  texture, nuclei format, and others for the cells nuclei, this
  variety depends on different factors as: Type of lesion, stain
  process, sample acquisition, sensor/microscopy setup for image
  acquisition and others.

  The dataset at version `1.x` has 3 categories annotated, and at
  version `2.x` will have 7 categories. But, the principal
  objective to help at diagnostic/prognostic of these samples is
  to detect/identify/measure the Nucleolus Organizer Regions
  (NORs) inside each nucleus. The NORs (the black dots/parts
  inside the nuclei) were labeled as two different categories:
  Satellite and clusters.

  At figure 2, has an example with two highlighted nuclei. The
  nucleus at left (black highlighted) it's a nucleus with three
  clusters. The nucleus at right side (gray highlighted) it's a
  nucleus with one cluster (the black dot at the top of the
  nuclei) and two satellites (the other two black dots).

  ![Image from a tile highlighting two nuclei](./data/static_images/Figure2.jpg)

  For more explanations about the dataset, see the dataset pages,
  or their papers.





  To use the dataset along different approaches, different
  “formats” are required. This module will provide the correct
  transformation between the format provided by the annotation
  tool (LabelBox) and the current state-of-the-art formats (e.g.
  COCO). It will also make it possible to work with the data in
  DataFrame format, which I consider to be the easiest way
  perform the manipulation of these annotations. The dataframe
  format is not recommended or built for use in any specific deep
  learning library or approach. It was built only for
  manipulation of the dataset, to facilitate conversions between
  different formats, perform analysis, and internal use of this
  library.

  ```console
  $ CCAgT-converter -h  # to show help message
  ```


  ```console
  $ CCAgT-converter labelbox_to_COCO \
                      -t OD \
                      -r ./data/samples/sanitized_sample_labelbox.json\
                      -a ./data/samples/CCAgT_dataset_metadata.json\
                      -o ./data/samples/out/CCAgT_COCO_OD.json
  ```


  ```console
  $ CCAgT-converter labelbox_to_CCAgT \
                      -r ./data/samples/sanitized_sample_labelbox.json \
                      -a ./data/samples/CCAgT_dataset_metadata.json \
                      -o ./data/samples/out/CCAgT.parquet.gzip\
                      -p True
  ```

  ```console
  $ CCAgT-converter generate_masks \
                      -l ./data/samples/out/CCAgT.parquet.gzip\
                      -o ./data/samples/masks/semantic_segmentation/\
                      --split-by-slide
  ```


  ```console
  $ CCAgT-converter CCAgT_to_COCO \
                      -t PS \
                      -l ./data/samples/out/CCAgT.parquet.gzip \
                      -o ./data/samples/masks/panoptic_segmentation \
                      --out-file ./data/samples/out/CCAgT_COCO_PS.json
  ```



  Module responsible to create personalized versions of the
  dataset with the desired modifications. Things that can
  done: slice the images into smaller parts, select just images
  that have specific categories, create images with a specific
  category. This tool, will copy, or generate the images, and
  also generate a new CCAgT annotations file, based on the
  desired options!

  First, if desired, the tool will remove images that do not have
  the desired categories:
  >- `--remove-images-without` with the categories ids, will
  remove all images that don't have the categories passed as
  parameter.
  >- `--remove-annotations-different` with the categories ids,
  will remove all annotations that have different categories
  than the parameter.

  Second, the tool allows selecting what will be the format
  of the images:
  >- `--slice-images` to slice the images into sub parts;
  >- `--extract` to create images with a unique category
  (centralized into the new image);
  >- `--labels` (to be used with `--extract`) path for the
  CCAgT file with the labels;
  >- `--paddings` (to be used with `--extract`) in percent
  (float values) or pixels (integer values) select, the size of
  paddings to apply;
  >- Without any parameter, will just copy the original dataset

  Third, and last, can (re)check if all images has the desired
  categories, and delete with don't have.
  >- `--check-if-all-have-at-least-one-of` to verify if the
  image have at least one of the categories IDs passed as
  parameter;
  >- `--delete` if desired, delete images that don't have at
  least one of the categories.
  >- `--generate-masks` if desired, will generate the masks
  based on the new CCAgT annotations file.

  **Check all option with: ** `CCAgT-utils create-subdataset -h`

  Example creates a subdataset with images sliced into 2x2
  (1 image (1600x1200) -> 4 images (800x600)), and remove images
  do not have any information (images with just background).

  ```console

  $ mkdir /tmp/example_dataset
  $ mkdir /tmp/example_dataset/images/
  $ mkdir /tmp/example_dataset/masks/
  $ cp -r ./data/samples/images/ /tmp/example_dataset/images/
  $ cp -r ./data/samples/masks/semantic_segmentation/ /tmp/example_dataset/masks/


  $ CCAgT-utils create-subdataset \
                      -name dataset_sliced_into2x2 \
                      --original /tmp/example_dataset/ \
                      --output /tmp/ \
                      --remove-images-without 1 2 3 4 5 6 7\
                      --slice-images 2 2
  ```

  With this tool, various datasets (based on the original
  dataset) can be created, be creative 😊 at yours experiments.


  Module responsible for assisting in the display or creation
  of figures from the dataset.

  ```console
  usage: CCAgT-visualization -h  # to show help message
  ```


  ```console
  $ CCAgT-visualization show \
                          -l ./data/samples/out/CCAgT.parquet.gzip\
                          -a ./data/samples/CCAgT_dataset_metadata.json\
                          -d ./data/samples/images/
  ```


  ```console
  $ CCAgT-visualization show \
                          -t image-and-mask\
                          -l ./data/samples/out/CCAgT.parquet.gzip\
                          -a ./data/samples/CCAgT_dataset_metadata.json\
                          -d ./data/samples/images/\
                          -m ./data/samples/masks/semantic_segmentation/
  ```


  ```console
  $ CCAgT-visualization show \
                          -t image-with-boxes-and-mask\
                          -l ./data/samples/out/CCAgT.parquet.gzip\
                          -a ./data/samples/CCAgT_dataset_metadata.json\
                          -d ./data/samples/images/\
                          -m ./data/samples/masks/semantic_segmentation/
  ```


pkgId: 1b105d178f618a4541d21fa959606d7507b467d76053485822cfac5f92e2bdf8
name: python-CCF-translator
arch: src
version: 0.22
epoch: 0
release: 1
summary: a package to translate data between common coordinate templates
url: https://github.com/Neural-Systems-at-UIO/CCF_translator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CCF-translator-0.22-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/CCF-translator)

  A tool for translating between common coordinate frameworks using deformation matrices.
  A longstanding problem in NeuroInformatics has been the inability to easily translate data between common coordinate frameworks. CCF_translator aims to solve this. By connecting each new space to an existing one, we can construct a graph of deformations. This means that data can be translated as long as there is a route from one space to another, even if that route passes through multiple other spaces. Now, when new templates for new modalities, strains, or ages are released, users will not be subdivided into unrelated spaces. As long as they are connected to a space which exists in our network, they will be fully connected to all other spaces.

  CCF_translator can also interpolate between spaces and create a new intermediate space. This is primarily useful for development, where, for instance, the midpoint between day 5 and day 7 can be taken and used as a postnatal day 6 reference. It could also be useful for making references of disease progression.

  ![a graph of all the available spaces and how they are connected. the spaces are nodes with the space name written on top of them, the edges show which spaces are connected to which other spaces.](https://raw.githubusercontent.com/Neural-Systems-at-UIO/CCF_translator/main/media/graph.png)

  One way you can use CCF_translator is to view data from one space, in another space. For instance the allen connectivity dataset shows projections from viral tracing studies in the adult brain. We can take any of these projection datasets and view them in the developing age, for instance post natal day 9.
  ![an image which shows a viral tracing study overlaid on the allen adult ccfv3 template. it shows that same viral tracing data transformed and overlaid on a post natal day 9 template. between the two images is an arrow pointing from the adult to the post natal day 9 brain, above which is text saying CCF_translator, implying that CCF_translator was used to transform the data from adult to post natal day 9.](https://raw.githubusercontent.com/Neural-Systems-at-UIO/CCF_translator/main/media/allen_connectivity_transform.png)

  CCF_translator can be installed by running
  ```
  pip install CCF-translator
  ```

  the name in CCF_translator aims to copy the name of atlases in the brainglobe_atlasapi when possible.
  | Framework Name | name in api | supported age range
  | -------------- | ----------- | -----------
  | Allen mouse CCFv3 | allen_mouse | 56
  | Demba developmental mouse | demba_dev_mouse| 4-56
  | Gubra lightsheet mouse | perens_lsfm_mouse| 56
  | Gubra MRI mouse | perens_mri_mouse| 56
  | Gubra STPT mouse | perens_stpt_mouse| 56
  | Princeton lighsheet mouse | princeton_mouse| 56

  **Transforming points**
  To take a coordinate in one volume and find the equivalent coordinate in a second volume is quite simple in CCF_translator.
  ```python
  import numpy as np
  import CCF_translator

  points = np.array([(286,250,267), (414,247,452)])
  pset = CCF_translator.PointSet(points, 'demba_dev_mouse', voxel_size_micron=20, age_PND=56)
  pset.transform(target_age=56, target_space='allen_mouse')
  print(f"new points are {pset.values}")

  ```
  ```
  new points are [[267 250 286] [452 247 414]]
   ```
  **Transforming volumes**

  To run the volume examples you will want to install brainglobe-atlasapi using the following
  ```
  pip install brainglobe-atlasapi
  ```

  Transforming a volume is equally simple, here we get the volume from the brainglobe api, but you can load it however you like. In the Demba space the valid ages are from 4 to 56, and all of these are valid targets for transformation.
  ```python
  from brainglobe_atlasapi.bg_atlas import BrainGlobeAtlas
  import CCF_translator


  voxel_size_micron = 10
  space_name = r"allen_mouse"
  atlas = BrainGlobeAtlas("{space_name}_{voxel_size_micron}um")
  source_age = 56
  target_age= 32

  CCFT_vol = CCF_translator.Volume(
      values = atlas.reference,
      space = 'allen_mouse',
      voxel_size_micron=voxel_size_micron,
      segmentation_file=False,
      age_PND = source_age
  )

  CCFT_vol.transform(target_age, 'demba_dev_mouse')
  CCFT_vol.save(rf"demo_data/P{target_age}_template_{voxel_size_micron}um.nii.gz")
  ```

  If you would like to add a new space or connect an existing one, please create a deformation matrix and/or describe the required reorientation, flipping, cropping, and padding of the axis between this space and one that already exists in the network, and then open an issue in this repository.  Ideally, choose a space which covers all the areas which are covered in your space. While the Allen CCFv3 is very popular, it is missing the anterior olfactory bulb and the caudal portion of the cerebellum and brain stem, so it is not the optimal choice.


  CCF_translator was first described in [DeMBA: a developmental atlas for navigating the mouse brain in space and time](https://www.biorxiv.org/content/10.1101/2024.06.14.598876v1). If you use CCF_translator, please cite that paper.


pkgId: 5797a33a5173168fa0e5c6d43d678b1c8280a9fc056ad7c95801d29afc8f6540
name: python-CCMetagen
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Microbiome classification pipeline
url: https://github.com/vrmarcelino/CCMetagen.git
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CCMetagen-1.5.0-1.src.rpm
checksum_type: sha256
description:
  CCMetagen processes sequence alignments produced with [KMA](https://bitbucket.org/genomicepidemiology/kma), which implements the ConClave sorting scheme to achieve highly accurate read mappings. The pipeline is fast enough to use the whole NCBI nt collection as reference, facilitating the inclusion of understudied organisms, such as microbial eukaryotes, in metagenome surveys. CCMetagen produces ranked taxonomic results in user-friendly formats that are ready for publication or downstream statistical analyses.

  If you this tool, please cite CCMetagen and KMA:

    * [Marcelino VR, Clausen PT, Buchman J, Wille M, Iredell JR, Meyer W, Lund O, Sorrell T, Holmes EC. 2019. CCMetagen: comprehensive and accurate identification of eukaryotes and prokaryotes in metagenomic data. Genome Biology. 2020 Dec;21(1):1-5.](https://genomebiology.biomedcentral.com/articles/10.1186/s13059-020-02014-2)

    * [Clausen PT, Aarestrup FM, Lund O. 2018. Rapid and precise alignment of raw reads against redundant databases with KMA. BMC bioinformatics. 2018 Dec;19(1):307.](https://bmcbioinformatics.biomedcentral.com/articles/10.1186/s12859-018-2336-6)

  Besides the guidelines below, we also provide a tutorial to reproduce our metagenome clasisfication analyses of the microbiome of wild birds [here](https://github.com/vrmarcelino/CCMetagen/tree/master/docs/tutorial).

  The guidelines below will guide you in using the command-line version of the CCMetagen pipeline.

  CCMetagen is also available as a web service at https://cge.food.dtu.dk/services/CCMetagen/.
  Note that we recommend using this command-line version to analyze data exceeding 1.5Gb.




  We recommend installing CCMetagen through [conda](https://docs.conda.io/en/latest/). This will install CCMetagen along with all of its required dependencies.

  After installing conda, you can create a new environment with CCMetagen through the following command:

  ```
  conda create -n ccmetagen ccmetagen -c bioconda -c conda-forge
  ```

  You can then activate your environment with:

  ```
  conda activate ccmetagen
  ```

  The `-n ccmetagen` flag will name the environment as `ccmetagen`, but you can choose any different name that you'd like. The `ccmetagen` after that specifies that you'd like the CCMetagen package installed into that environment.
  Finally, the `-c bioconda -c conda-forge` specifies that you'd like to use the Bioconda and Conda-Forge channels, which host CCMetagen and its dependencies.

  You can also install CCMetagen from source, or using pip, the Python package manager. For that, follow the installation instructions in the deprecated README file in the [docs](https://github.com/vrmarcelino/CCMetagen/tree/master/docs/old_repository_README.md).

  Check your CCMetagen installation by running `CCMetagen.py --version` on your command-line.




  After installing CCMetagen, you will need a reference database to perform taxonomic classification. There are two ways to obtain this:

  **Option 1** Download the indexed (ready-to-go) nt from [here](https://melbourne.figshare.com/projects/CCMetagen_databases/195755).
  Download the ncbi_nt_kma file (103GB zipped file) or the RefSeq_bf.zip (90GB zipped file)
  Unzip the database, e.g.: `unzip ncbi_nt_kma`.
  The nt database contains the whole in NCBI nucleotide collection (from 2019, updated database to be released soon!), and therefore is suitable to identify a range of microorganisms, including prokaryotes and eukaryotes.

  There are two versions of the nt database, the one previously mentioned, and another one that does not contain environemntal or artificial sequences. The file ncbi_nt_no_env_11jun2019.zip contains all ncbi nt entries excluding the descendants of environmental eukaryotes (taxid 61964), environmental prokaryotes (48479), unclassified sequences (12908) and artificial sequences (28384).

  **Option 2:** Build your own reference database (recommended!)
  Follow the instructions in the [KMA website](https://bitbucket.org/genomicepidemiology/kma) to index the database.
  It is important that taxids are incorporated in sequence headers for processing with CCMetagen. Sequence headers should look like
  `>1234|sequence_description`, where 1234 is the taxid.
  We provide scripts to rename sequences in the nt database [here](https://github.com/vrmarcelino/CCMetagen/tree/master/docs/benchmarking/rename_nt).

  If you want to use the RefSeq database, the format is similar to the one required for Kraken. The [Opiniomics blog](http://www.opiniomics.org/building-a-kraken-database-with-new-ftp-structure-and-no-gi-numbers/) describes how to download sequences in an adequate format. Note that you still need to build the index with KMA: `kma_index -i refseq.fna -o refseq_indexed -NI -Sparse -` or `kma_index -i refseq.fna -o refseq_indexed -NI -Sparse TG` for faster analysis.




    * First map sequence reads (or contigs) to the database with **KMA**.

  For paired-end files:

  ```
  kma -ipe $SAMPLE_R1 $SAMPLE_R2 -o sample_out_kma -t_db $db -t $th -1t1 -mem_mode -and -apm f
  ```

  For single-end files:
  ```
  kma -i $SAMPLE -o sample_out_kma -t_db $db -t $th -1t1 -mem_mode -and
  ```

  If you want to calculate abundance in reads per million (RPM) or in number of reads (fragments), or if you want to calculate the proportion of mapped reads, add the flag -ef (extended features):
  ```
  kma -ipe $SAMPLE_R1 $SAMPLE_R2 -o sample_out_kma -t_db $db -t $th -1t1 -mem_mode -and -apm f -ef
  ```

  Where:

  - `$db` is the path to the reference database
  - `$th` is the number of threads
  - `$SAMPLE_R1` is the path to the mate1 of a paired-end metagenome/metatranscriptome sample (fastq or fasta)
  - `$SAMPLE_R2` is the path to the mate2 of a paired-end metagenome/metatranscriptome sample (fastq or fasta)
  - `$SAMPLE` is the path to a single-end metagenome/metatranscriptome file (reads or contigs)

  Then run `CCMetagen.py`:

  ```
  CCMetagen.py -i $sample_out_kma.res -o results
  ```

  Where $sample_out_kma.res is alignment results produced by KMA.

  Note that if you are running CCMetagen from the local folder (instead of adding it to your path), you may need to add 'python' before CCMetagen: `python CCMetagen.py -i $sample_out_kma.res -o results`

  Done! This will make an additional quality filter and output a text file with ranked taxonomic classifications and a krona graph file for interactive visualization.

  An example of the CCMetagen output can be found [here (.csv file)](https://github.com/vrmarcelino/CCMetagen/blob/master/docs/tutorial/figs_tutorial/Turnstone_Temperate_Flu_Ng.res.csv) and [here (.html file)](https://htmlpreview.github.io/?https://github.com/vrmarcelino/CCMetagen/blob/master/docs/tutorial/figs_tutorial/Turnstone_Temperate_Flu_Ng.res.html).

  <img src=docs/tutorial/figs_tutorial/krona_photo.png width="500" height="419.64">

  In the .csv file, you will find the depth (abundance) of each match.



  **Depth can be estimated in four ways:**

  1. By applying an additional correction for template length (default in KMA and CCMetagen);
  2. By counting the number of nucleotides matching the reference sequence (use flag --depth_unit nc);
  3. By calculating depth in Reads Per Million (RPM, use flag --depth_unit rpm); or
  4. By counting the number of fragments (i.e. number of PE reads matching to teh reference sequence, use flag --depth_unit fr). If you want RPM or fragment units, you will need to suply the .mapstats file generated with KMA (which you get when running kma with the flag '-ef').




  You can **adjust the stringency of the taxonomic assignments** by adjusting the minimum coverage (--coverage), the minimum abundance (--depth), and the minimum level of sequence similarity (--query_identity). Coverage is the percentage of bases in the reference sequence that is covered by the consensus sequence (your query), it can be over 100% when the consensus sequence is larger than the reference (due to insertions for example). You can also adjust the KMA settings to facilitate the identification of more distant-related taxa (see below)

  If you change the default depth unit, we recommend adjusting the minimum abundance (--depth) to remove taxa found in low abundance accordingly. For example, you can use -d 200 (200 nucleotides) when using --depth_unit nc, which is similar to -d 0.2 when using the default '--depth_unit kma' option. If you choose to calculate abundances in RPM, you may want to adjust the minimum abundance according to your sequence depth.
  For example, to calculate abundances in RPM, and filter out all matches with less than one read per million:

  ```
  CCMetagen.py -i $sample_out_kma.res -o results -map $sample_out_kma.mapstat --depth_unit rpm --depth 1
  ```

  If you would like to know the **proportion of reads mapped** to each template, run kma with the '-ef' flag. This will generate a file with the '.mapstat' extension. Then provide this file to CCMetagen (-map $sample_out_kma.mapstat) and add the flag '-ef y':

  ```
  CCMetagen.py -i $sample_out_kma.res -o results -map $sample_out_kma.mapstat -ef y
  ```
  This will filter the .mapstat file, removing the templates that did not pass CCMetagen's quality control, will add the percentage of mapped reads for each template and will output a file with extension 'stats_csv'. It will also output the overall proportion of reads mapped to these templates in the terminal. For more details about the additional columns of this file, please check [KMA's manual](https://bitbucket.org/genomicepidemiology/kma/src/master/KMAspecification.pdf).

  When working with highly complex environemnts for which reference databases are scarce (e.g. many soil and marine metagenomes), it is common to obtain a low proportion of classified reads, especially if the sequencing depth is low. For a more sensitive analysis, besides relaxing the CCMetatgen settings, you can adjust the KMA aligner settings, by for example: removing the `-and` and the `-apm f` flags, so that you can get a match even when the reference sequences are not significantly overrepresented or when only one of the PE reads maps to the template. Check the [KMA manual](https://bitbucket.org/genomicepidemiology/kma/src/master/KMAspecification.pdf) for more details. It can also be useful to build a customized reference database with additional genomes of organisms that are closely related to what you expect to find in your samples.


  The taxonomic classifications reflect the sequence similarity between query and reference sequences, according to default or user-defined similarity thresholds. For example, if a match is 97% similar to the reference sequence, the match will not get a species-level classification. If the match is 85% similar to the reference sequence, then the species, genus and family-level classifications will be 'none'.
  Note that this is different from identifications tagged as unk_x (unknown taxa). These unknowns indicate taxa where higher-rank classifications have not been defined (according to the NCBI taxonomy database), and it is unrelated to sequence similarity.


  For a list of options to customize your analyze, type:
  ```
  CCMetagen.py -h
  ```

    * **To get the abundance of each taxon, and/or summarize results for multiple samples, use CCMetagen_merge**:
  ```
  CCMetagen_merge.py -i $CCMetagen_out
  ```

  Where `$CCMetagen_out` is the folder containing the CCMetagen taxonomic classifications.
  The results must be in .csv format (default or '--mode text' output of CCMetagen), and these files **must end in ".ccm.csv"**.

  The flag '-t' define the taxonomic level to merge the results. The default is species-level.

  You can also filter out specific taxa, at any taxonomic level:

  Use flag -kr to keep (k) or remove (r) taxa.
  Use flag -l to set the taxonomic level for the filtering.
  Use flag -tlist to list the taxa to keep or remove (separated by comma).

  EX1: Filter out bacteria: `CCMetagen_merge.py -i $CCMetagen_out -kr r -l Kingdom -tlist Bacteria`

  EX2: Filter out bacteria and Metazoa: `CCMetagen_merge.py -i $CCMetagen_out -kr r -l Kingdom -tlist Bacteria, Metazoa`

  EX3: Merge results at family-level, and remove Metazoa and Viridiplantae taxa at Kingdom level:
  ```
  CCMetagen_merge.py -i $CCMetagen_out -t Family -kr r -l Kingdom -tlist Metazoa,Viridiplantae -o family_table
  ```

  For species-level filtering (where there is a space in taxa names), use quotation marks.
  Ex 4: Keep only _Escherichia coli_ and _Candida albicans_:
  ```
  CCMetagen_merge.py -i 05_KMetagen/ -kr k -l Species -tlist "Escherichia coli,Candida albicans"
  ```

  If you only have one sample, you can also use CMetagen_merge to get one line per taxa.

  To see all options, type:
  ```
  CCMetagen_merge.py -h
  ```
  This file should look like [this](https://github.com/vrmarcelino/CCMetagen/blob/master/tutorial/figs_tutorial/Bird_family_table_filtered.csv).


  * **To extract sequences of a given taxon, use CCMetagen_extract_seqs**:

  This script will produce a fasta file containing all reads assigned to a taxon of interest.
  Ex: Generate a fasta file containing all sequences that mapped to the genus Eschericha:
  ```
  CCMetagen_extract_seqs.py -iccm $CCMetagen_out -ifrag $sample_out_kma.frag -l Genus -t Eschericha
  ```

  Where `$CCMetagen_out` is the .csv file generated with CCMetagen and `$sample_out_kma.frag` is the .frag file generated with KMA. The frag file needs to be decompressed: `gunzip *.frag.gz`

  For species-level filtering (where there is a space in taxon names), use quotation marks.
  Ex: Generate a fasta file containing all sequences that mapped to _E. coli_:
  ```
  CCMetagen_extract_seqs.py -iccm $CCMetagen_out -ifrag $sample_out_kma.frag -l Species -t "Escherichia coli"
  ```


  **Check out our [tutorial](https://github.com/vrmarcelino/CCMetagen/tree/master/docs/tutorial) for an applied example of the CCMetagen pipeline.**





  * Error taxid not found.
    You probably need to update your local ETE3 database, which contains the taxids and lineage information:
  ```
  python
  from ete3 import NCBITaxa
  ncbi = NCBITaxa()
  ncbi.update_taxonomy_database()
  quit()
  ```

  * TypeError: concat() got an unexpected keyword argument 'sort'.
    If you get this error, please update the python module pandas:
  ```
  pip install pandas --upgrade --user
  ```

  * WARNING: no NCBI's taxid found for accession [something], this match will not get taxonomic ranks

    This is not an error, this is just a warning indicating that one of your query sequences matchs to a genbank record for which the NCBI taxonomic identifier (taxid) is not known. CCMetagen therefore will not be able to assign taxonomic ranks to this match, but you will still be able to see it in the output file.

  * KeyError: "['Superkingdom' 'Kingdom' 'Phylum' 'Class' 'Order' 'Family' .... ] not in index"
    Make sure that the output of CCMetagen ends in '.csv'.

  * The results of the CCMetagen_merge.py at different taxonomic levels do not sum up.
    As explained above, this script merges all unclassified taxa at a given taxonomic level. For example, if you have 20 matches to the genus _Candida_, but only 2 matches were classified at the species level, the output of CCMetagen_merge.py -t Species (default) will only have the abundances of two classified _Candida_ species, while the others will be merged with the "Unclassified" taxa. The output of CCMetagen_merge.py -t Genus however will contain all 20 matches.
    If this behaviour is undesirable, one option is to disable the similarity thresholds (use flag -off) - so that all taxonomic levels are reported regardless of their similarity to the reference sequence. Alternatively, you can cluster species at the 'Closest_match' (using the flag --tax_level Closest_match).




  CCMetagen:
  ```
  usage: CCMetagen.py [-h] [-m MODE] -i RES_FP [-o OUTPUT_FP]
                      [-r REFERENCE_DATABASE] [-ef EXTENDED_OUTPUT_FILE]
                      [-du DEPTH_UNIT] [-map MAPSTAT] [-d DEPTH] [-c COVERAGE]
                      [-q QUERY_IDENTITY] [-p PVALUE] [-st SPECIES_THRESHOLD]
                      [-gt GENUS_THRESHOLD] [-ft FAMILY_THRESHOLD]
                      [-ot ORDER_THRESHOLD] [-ct CLASS_THRESHOLD]
                      [-pt PHYLUM_THRESHOLD] [-off TURN_OFF_SIM_THRESHOLDS]
                      [--version]

  optional arguments:
    -h, --help            show this help message and exit
    -m MODE, --mode MODE  what do you want CCMetagen to do? Valid options are
                          'visual', 'text' or 'both': text: parses kma, filters
                          based on quality and output a text file with taxonomic
                          information and detailed mapping information visual:
                          parses kma, filters based on quality and output a
                          simplified text file and a krona html file for
                          visualization both: outputs both text and visual file
                          formats. Default = both
    -i RES_FP, --res_fp RES_FP
                          Path to the KMA result (.res file)
    -o OUTPUT_FP, --output_fp OUTPUT_FP
                          Path to the output file. Default = CCMetagen_out
    -r REFERENCE_DATABASE, --reference_database REFERENCE_DATABASE
                          Which reference database was used. Options: UNITE,
                          RefSeq or nt. Default = nt
    -ef EXTENDED_OUTPUT_FILE, --extended_output_file EXTENDED_OUTPUT_FILE
                          Produce an extended output file that includes the
                          percentage of classified reads. Options: y or n. To
                          use this featire, you need to generate the mapstat
                          file when required unning KMA (use flag -ef), and use
                          it as input in CCMetagen (flag --mapstat). Default = n
    -du DEPTH_UNIT, --depth_unit DEPTH_UNIT
                          Desired unit for Depth(abundance) measurements.
                          Default = kma (KMA default depth, which is the number
                          of nucleotides overlapping each template, divided by
                          the lengh of the template). Alternatively, you can
                          have abundance calculated in Reads Per Million (RPM,
                          option 'rpm'), in number of nucleotides overlaping the
                          template (option 'nc') or in number of fragments (i.e.
                          PE reads, option 'fr'). If you use the 'nc', 'rpm' or
                          'fr' options, remember to change the default --depth
                          parameter accordingly. Valid options are nc, rpm, fr
                          and kma
    -map MAPSTAT, --mapstat MAPSTAT
                          Path to the mapstat file produced with KMA when using
                          the -ef flag (.mapstat). Required when calculating
                          abundances in RPM or in number of fragments, or when
                          producing the extended_output_file
    -d DEPTH, --depth DEPTH
                          minimum sequencing depth. Default = 0.2. The unit
                          corresponds to the one used with --depth_unit If you
                          use --depth_unit different from the default, change
                          this accordingly.
    -c COVERAGE, --coverage COVERAGE
                          Minimum coverage. Default = 20 (i.e. 20% of the
                          reference sequence)
    -q QUERY_IDENTITY, --query_identity QUERY_IDENTITY
                          Minimum query identity (Phylum level). Default = 50
    -p PVALUE, --pvalue PVALUE
                          Minimum p-value. Default = 0.05.
    -st SPECIES_THRESHOLD, --species_threshold SPECIES_THRESHOLD
                          Species-level similarity threshold. Default = 98.41
    -gt GENUS_THRESHOLD, --genus_threshold GENUS_THRESHOLD
                          Genus-level similarity threshold. Default = 96.31
    -ft FAMILY_THRESHOLD, --family_threshold FAMILY_THRESHOLD
                          Family-level similarity threshold. Default = 88.51
    -ot ORDER_THRESHOLD, --order_threshold ORDER_THRESHOLD
                          Order-level similarity threshold. Default = 81.21
    -ct CLASS_THRESHOLD, --class_threshold CLASS_THRESHOLD
                          Class-level similarity threshold. Default = 80.91
    -pt PHYLUM_THRESHOLD, --phylum_threshold PHYLUM_THRESHOLD
                          Phylum-level similarity threshold. Default = 0 - not
                          applied
    -off TURN_OFF_SIM_THRESHOLDS, --turn_off_sim_thresholds TURN_OFF_SIM_THRESHOLDS
                          Turns simularity-based filtering off. Options = y or
                          n. Default = n
    --version             show program's version number and exit
   ```


pkgId: a0882d0b7eb056b17fb5d82ef145828a7fcfbd713169c87e47cc256af0f44799
name: python-CDK-pywrapper
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Python wrapper for CDK molecular descriptors and fingerprints
url: https://github.com/OlivierBeq/CDK_pywrapper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CDK-pywrapper-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  Python wrapper to ease the calculation of [CDK](https://cdk.github.io/) molecular descriptors and fingerprints.



  From source:

      git clone https://github.com/OlivierBeq/CDK_pywrapper.git
      pip install ./CDK_pywrapper

  with pip:

  ```bash
  pip install CDK-pywrapper
  ```



  ```python
  from CDK_pywrapper import CDK
  from rdkit import Chem

  smiles_list = [
    
    "n1cnc(c2cc(c(cc12)OCCOC)OCCOC)Nc1cc(ccc1)C#C",
    
    "CCC(=O)O[C@@H]1CC(=O)O[C@@H](C/C=C/C=C/[C@@H]([C@@H](C[C@@H]([C@@H]([C@H]1OC)O[C@H]2[C@@H]([C@H]([C@@H]([C@H](O2)C)O[C@H]3C[C@@]([C@H]([C@@H](O3)C)OC(=O)CC)(C)O)N(C)C)O)CC=O)C)O)C",
    
    "C1=CC(=CC=C1C(=O)NC(CCC(=O)OCC[Se]C#N)C(=O)O)NCC2=CN=C3C(=N2)C(=O)NC(=N3)N",
    
    "N.N.Cl[Pt]Cl"
  ]
  mols = [Chem.AddHs(Chem.MolFromSmiles(smiles)) for smiles in smiles_list]

  cdk = CDK()
  print(cdk.calculate(mols))
  ```

  The above calculates 222 molecular descriptors (23 1D and 200 2D).<br/>

  The additional 65 three-dimensional (3D) descriptors may be obtained with the following:
  :warning: Molecules are required to have conformers for 3D descriptors to be calculated.<br/>

  ```python
  from rdkit.Chem import AllChem

  for mol in mols:
      _ = AllChem.EmbedMolecule(mol)

  cdk = CDK(ignore_3D=False)
  print(cdk.calculate(mols))
  ```


  To obtain molecular fingerprint, one can used the following:

  ```python
  from CDK_pywrapper import CDK, FPType
  cdk = CDK(fingerprint=.PubchemFP)
  print(cdk.calculate(mols))
  ```

  The following fingerprints can be calculated:

  | FPType    | Fingerprint name                                                                   |
  |-----------|------------------------------------------------------------------------------------|
  | FP        | CDK fingerprint                                                                    |
  | ExtFP     | Extended CDK fingerprint (includes 25 bits for ring features and isotopic masses)  |
  | EStateFP  | Electrotopological state fingerprint (79 bits)                                     |
  | GraphFP   | CDK fingerprinter ignoring bond orders                                             |
  | MACCSFP   | Public MACCS fingerprint                                                           |
  | PubchemFP | PubChem substructure fingerprint                                                   |
  | SubFP     | Fingerprint describing 307 substructures                                           |
  | KRFP      | Klekota-Roth fingerprint                                                           |
  | AP2DFP    | Atom pair 2D fingerprint as implemented in PaDEL                                   |
  | HybridFP  | CDK fingerprint ignoring aromaticity                                               |
  | LingoFP   | LINGO fingerprint                                                                  |
  | SPFP      | Fingerprint based on the shortest paths between two atoms                          |
  | SigFP     | Signature fingerprint                                                              |
  | CircFP    | Circular fingerprint                                                               |



  ```python
  class CDK(ignore_3D=True, fingerprint=None, nbits=1024, depth=6):
  ```

  Constructor of a CDK calculator for molecular descriptors or fingerprints

  Parameters:

  - ***ignore_3D  : bool***
    Should 3D molecular descriptors be calculated (default: False). Ignored if a fingerprint is set.
  - ***fingerprint  : FPType***
    Type of fingerprint to calculate (default: None). If None, calculate descriptors.
  - ***nbits  : int***
    Number of bits in the fingerprint.
  - ***depth  : int***
    Depth of the fingerprint.
  <br/>
  <br/>
  ```python
  def calculate(mols, show_banner=True, njobs=1, chunksize=1000):
  ```

  Default method to calculate CDK molecular descriptors and fingerprints.

  Parameters:

  - ***mols  : Iterable[Chem.Mol]***
    RDKit molecule objects for which to obtain CDK descriptors.
  - ***show_banner  : bool***
    Displays default notice about CDK.
  - ***njobs  : int***
    Maximum number of simultaneous processes.
  - ***chunksize  : int***
    Maximum number of molecules each process is charged of.


pkgId: b965f641a4445a2628a35d0ffde992d83a63e078c063caf253229b0413635482
name: python-CDMIR
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A pip package
url: https://pypi.org/project/CDMIR/
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CDMIR-0.0.4-1.src.rpm
checksum_type: sha256
description:
  CDMIR is a python package for causal discovery, modeling and reasoning that is developed from [DMIR Lab](https://dmir.gdut.edu.cn/), GDUT.

  The package is under active development. Feedbacks (issues, suggestiong, etc.) are highly encouraged.
  ![causal-discovery](./images/causal-discovery.png)



  - Python3
  - numpy
  - pandas
  - scipy>=1.7.3
  - scikit-learn
  - torch>=1.7.1
  - networkx
  - matplotlib
  - tick



  Team Leaders: Ruichu Cai, Zhifeng Hao

  Coordinators: Wei Chen

  Thanks to the following developers for this project:

  - [@chenweiDelight](https://github.com/chenweiDelight)
  - [@zhi-yi-huang](https://github.com/zhi-yi-huang)
  - [@miumiujiang12138](https://github.com/miumiujiang12138)
  - [@WeilinChen507](https://github.com/WeilinChen507)
  - [@wean2016](https://github.com/wean2016)
  - [@Jie-Qiao](https://github.com/Jie-Qiao)
  - [@jinshi201](https://github.com/jinshi201)
  - [@kanseaveg](https://github.com/kanseaveg)
  - [@Boyle-Coffee](https://github.com/)

  Please feel free to open an issue if you find anything unexpected. And please create pull requests, perhaps after passing unittests in 'tests/', if you would like to contribute to cdmir. We are always targeting to make our community better!


pkgId: e87b7f75b23cbfaf9529d53335c7225c4e9a4fbe83cb57547a39eaf084fadfb2
name: python-CDSupdate
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Auto-updater of data from the Climate Data Store
url: https://github.com/yrobink/CDSupdate
rpm_license: GNU-GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CDSupdate-2.0.0-1.src.rpm
checksum_type: sha256
description:
  CDSupdate is a Python package that automates the process of retrieving, processing, and managing climate data from the Climate
  Data Store (CDS) API. The tool generates daily climate data summaries, performs calculations to create custom variables such as
  relative humidity and heat index which serve as risk assessments, and organizes the data into a user-friendly format.




  CDSupdate requires the following packages:

  - `numpy`
  - `pandas`
  - `xarray`
  - `netCDF4`
  - `cftime`
  - `cdsapi`
  - `windows-curses` (only for Microsoft Windows users)

  From pip:

  ~~~shell
  pip3 install CDSupdate
  ~~~

  Or from source:

  ~~~shell
  git clone https://github.com/yrobink/CDSupdate.git
  cd CDSupdaye
  pip3 install .
  ~~~

  This adds the `CDSupdate` package in your python installation, and the command
  `cdsupdate`.



  Start by read the documentation with:

  ~~~shell
  cdsupdate --help
  ~~~

  As example, to download the daily mean temperature over the North Atlantic
  (80W-50E,5N,72N) between 2019-11-09 and 2022-01-17 in the directory `odir`, just run:

  ~~~shell
  cdsupdate --log info test.log --period 2019-11-09/2022-01-17 --cvar tas --area NorthAtlantic --odir odir
  ~~~



  You can use this [DOI:10.5281/zenodo.7991331](https://doi.org/10.5281/zenodo.7991331)



  Copyright(c) 2022 / 2024 Yoann Robin, Andreia Hisi

  This file is part of CDSupdate.

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

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

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


pkgId: c06d98924ba8112f76076672879b8353d8301738c01883ed1d56c4e20a1fb2c9
name: python-CDynamics
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Plot Julia Sets Of Complex Valued Functions
url: https://pypi.org/project/CDynamics/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CDynamics-3.0.2-1.src.rpm
checksum_type: sha256
description:
  A package that allows users to visualize Julia sets of complex-valued holormorhphic self-maps on the Riemann sphere.


pkgId: 22ab77af095fb197545e2742ab7b1cf7f384dae844599e3af1c1deaad1c9e4b6
name: python-CEA-Wrap
arch: src
version: 1.7.4
epoch: 0
release: 1
summary: A Python-Based wrapper for the NASA CEA Thermochemical Code
url: https://github.com/civilwargeeky/CEA_Wrap
rpm_license: GNU GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CEA-Wrap-1.7.4-1.src.rpm
checksum_type: sha256
description:
     p_f  |  %f     | Percent fuel by weight
     f_o  |  f/o    | Fuel-to-oxidant weight ratio
     o_f  |  o/f    | Oxidant-to-fuel weight ratio
     phi  |  phi    | Equivalence ratios in terms of fuel-to-oxidant weight ratios (eq. (9.19) in Gordon and McBride, 1994)
     r_eq |  r      | Chemical equivalence ratios in terms of valences (eq. (9.18) in Gordon and McBride, 1994)

  * `data = .run([*materials])`
  Run the CEA problem, returning an "Output" object, which is similar to a dictionary (keys and values specified later in this documentation)
    * Inputs are optionally `Material`s to be used in this run. If materials are not specified as an initial parameter or with .set_materials, you can list them here.
  * `.set_absolute_o_f()`
  Have you ever specified all your components in absolute percentages, and then have to manually calculate the o_f ratio based on what is fuel and what is oxidizer?
  Well no more! Just call this function and we calculate the correct o_f ratio for you so that your absolute percentages are correctly reflected in the problem.
  Functions off of the existing material list, so call this after setting materials. This works by summing wt_percent for all oxidizers and then dividing by the same for fuels. Then it sets o/f to this value.
  * `.set_pressure(pressure)` - sets pressure
  * `.set_materials([material1, material2, ...])` - provided a list of materials, sets the materials list
  * `.set_massf(massf)` - Sets massf to True or False
  * `.set_inserts(inserts)` - Set inserts to a space-separated string or list of materials or `Material`s
  * `.set_omits(omits)` - Sets omits, similar to inserts
  * `.set_filename(filename)` - Sets problem filename
  * `.set_pressure_units(units)` - Sets input pressure units
  * `.set_p_f(pf)` - Sets % Fuel for problem
  * `.set_f_o(f_o)` - Sets fuel/oxidizer ratio
  * `.set_o_f(o_f)` - Sets oxidizer/fuel ratio
  * `.set_phi(phi)` - Sets equivalence ratio
  * `.set_r_eq(r_eq)` - Sets valence equivalence ratio

  Very similar to an HP problem, but temperature is specified per-problem and material temperatures are ignored
  * `temperature`: default 298. Problem temperature
    * temperature can be specified later with .set_temperature
  * `temperature_units`: default 'k'. Options are 'k', 'c', 'r', 'f'
    * temperature_units can be specified later with .set_temperature_units

  **WARNING**: As far as I am aware, CEA is incapable of performing detonation calculations with condensed phase (solid) reactants. It will only handle gaseous reactants

  For `RocketProblem(*, **kwargs)`
  * `sup`: default 1, supersonic exit area/throat area ratio
    * sup can be specified later with .set_sup
  * `sub`: default None, subsonic exit/throat area ratio
    * sub can be specified later with .set_sub
  * **NOTE:** sup and sub cannot be specified at the same time
  * `ae_at`: alias for `sup`
    * ae_at can be specified later with .set_ae_at
  * `pip`: Pressure ratio of chamber pressure/exit pressure
    * pip can be specified later with .set_pip
  * `fac_ma`: Finite Area Combustor, with mass flow (mdot) / combustor chamber area. Units of (kg/s)/m^2
    * fac_ma can be specified later with .set_fac_ma
    * Cannot be specified at the same time as fac_ac
  * `fac_ac`: Finite Area Combustor, with ac/at: Ratio of combustor area to throat area
    * fac_ac can be specified later with .set_fac_ac
    * Cannot be specified at the same time as fac_ma
  * `analysis_type`: default "equilibrium", whether to use equilibrium reactions or frozen. For using frozen specify "frozen" or "frozen nfz=1" for frozen at the chamber or "frozen nfz=2" for frozen at the throat
  * `nfz`: default None, If `analysis_type` is "frozen", this will set the frozen location to the given point. 1 for chamber, 2 for throat
  * `custom_nfz`: default None, If `analysis_type` is "frozen", this is the position within the nozzle that composition will be frozen at. Uses the same unit as ae/at or pip. Example: custom_nfz=2 to freeze composition at ae/at=2

  * `.set_sup(sup)` - Sets supersonic area ratio
  * `.set_sub(sub)` - Sets subsonic area ratio
  * `.set_ae_at(sup)` - Sets supersonic area ratio
  * `.set_pip(pip)` - Sets pressure ratio
  * `.set_analysis_type(analysis, nfz=None, custom_nfz=None)` - Sets analysis type, with optional frozen specifications as above
  * `.set_fac_ma(fac)` - Sets finite area combustor, with mass flow/area ratio
  * `.set_fac_ac(fac)` - Sets finite area combustor, with combustor/throat area ratio
  * `.unset_fac()` - Unsets finite area combustor

  All Problem data objects are "Output" objects, which are similar to dictionaries, but can also be accessed with dot notation.
  For example if you had "data = problem.run_cea()", and wanted pressure, you could do either data.p or data["p"]
  In addition, all product dictionaries are also "Output" objects so to get H2O fraction, you could use data.prod_c.H2O or data["prod_c"]["H2O"] or data["prod_c"].H2O, etc.

  * `prod_c` - dictionary of chamber products, in mole or mass fractions (as specified by the 'massf' parameter in your problem definition)
  * `p` - pressure, bar
  * `t` - temperature, Kelvin
  * `h` - enthalpy, kJ/kg
  * `rho` - density, kg/m^3
  * `son` - sonic velocity, m/s
  * `visc` - burned gas viscosity, Pascal-Seconds
  * `mw` - molecular weight of products, kg/kmol
  * `cp` - constant-pressure specific heat capacity, kJ/(kg*K)
  * `gammas` - isentropic ratio of specific heats
  * `gamma` - "real" ratio of specific heats (multiplied by -(dLV/dLP)t)
  * `vel` - detonation velocity, m/s
  * `mach` - detonation mach number
  * `p_p1` - P/P1, ratio of detonation pressure to initial pressure
  * `t_t1` - T/T1, ratio of detonation temperature to initial pressure
  * `m_m1` - M/M1, ratio of detonation molecular weight to initial molecular weight
  * `rho_rho1` - RHO/RHO1, ratio of detonation density to initial density
  * `dLV_dLP_t` - (dLV/dLP)t, used to convert isentropic gamma to real gamma
  * `dLV_dLT_p` - (dLV/dLT)p
  * `phi` - weight-based equivalence ratio of oxidizer/fuel

  * `prod_c` - dictionary of chamber products, in mole or mass fractions  (as specified by the 'massf' parameter in your problem definition)
  * `p` - pressure, bar
  * `t` - temperature, Kelvin
  * `h` - enthalpy, kJ/kg
  * `rho` - density, kg/m^3
  * `son` - sonic velocity, m/s
  * `visc` - burned gas viscosity, Pascal-Seconds
  * `mw` - molecular weight of products, kg/kmol
  * `cp` - constant-pressure specific heat capacity, kJ/(kg*K)
  * `gammas` - isentropic ratio of specific heats
  * `gamma` - "real" ratio of specific heats (multiplied by -(dLV/dLP)t)
  * `dLV_dLP_t` - (dLV/dLP)t, used to convert isentropic gamma to real gamma
  * `dLV_dLT_p` - (dLV/dLT)p
  * `phi` - weight-based equivalence ratio of oxidizer/fuel

  * **NOTE : Properties are by default at exit. Chamber parameters are prefixed "c_" and throat properties "t_"**
  * **NOTE : Properties not defined for frozen flow are marked with an asterisk (*)**
  * **NOTE : All properties defined at the throat are also defined as "f_property" when Finite Area Combustor is enabled (defined fac_ac or fac_ma)**
  * `prod_c` - dictionary of chamber products, in mole or mass fractions (as specified by the 'massf' parameter in your problem definition)
  * `*prod_t` - dictionary of throat products, in mole or mass fractions (as specified by the 'massf' parameter in your problem definition)
  * `*prod_e` - dictionary of exit products, in mole or mass fractions (as specified by the 'massf' parameter in your problem definition)
  * `p` - pressure, bar
    * `t_p` - throat
    * `c_p` - chamber
  * `t` - temperature, Kelvin
    * `t_t` - throat
    * `c_t` - chamber
  * `h` - enthalpy, kJ/kg
    * `t_h` - throat
    * `c_h` - chamber
  * `rho` - density, kg/m^3
    * `t_rho` - throat
    * `c_rho` - chamber
  * `son` - sonic velocity, m/s
    * `t_son` - throat
    * `c_son` - chamber
  * `visc` - burned gas viscosity, Pascal-Seconds
    * `t_visc` - throat
    * `c_visc` - chamber
  * `cond` - burned gas thermal conductivity, W/(m K)
    * `t_cond` - throat
    * `c_cond` - chamber
  * `pran` - burned gas Prandtl number. Ratio of mass diffusivity to thermal diffusivity
    * `t_pran` - throat
    * `c_pran` - chamber
  * `mw` - molecular weight of all products, kg/kmol
    * `t_mw` - throat
    * `c_mw` - chamber
  * `m` - molecular weight calculated as the weight of all products divided by the number of gaseous moles (same as mw if no condensed phases as mw=m), kg/kmol
    * `t_m` - throat
    * `c_m` - chamber
  * `condensed` - True if there are condensed phase products (measured by m originally = 0), False otherwise
    * `t_condensed` - throat
    * `c_condensed` - chamber
  * `cp` - constant-pressure specific heat capacity, kJ/(kg*K)
    * `t_cp` - throat
    * `c_cp` - chamber
  * `gammas` - isentropic ratio of specific heats
    * `t_gammas` - throat
    * `c_gammas` - chamber
  * `gamma` - "real" ratio of specific heats (multiplied by -(dLV/dLP)t) (same as gammas for frozen flow)
    * `t_gamma` - throat
    * `c_gamma` - chamber
  * `isp` - ideal isp (ambient pressure = exit pressure), s
    * `t_isp` - throat
  * `ivac` - vacuum isp, s
    * `t_ivac` - throat
  * `cf` - ideally expanded thrust coefficient
    * `t_cf` - throat
  * `*dLV_dLP_t` - (dLV/dLP)t, multiply gammas by negative this to convert isentropic gamma to real gamma
    * `*t_dLV_dLP_t` - throat
    * `*c_dLV_dLP_t` - chamber
  * `*dLV_dLT_p` - (dLV/dLT)p, see the Mathematical Analysis in CEA_Wrap/assets for explanation
    * `*t_dLV_dLT_p` - throat
    * `*c_dLV_dLT_p` - chamber
  * `cstar` - characteristic velocity in chamber, m/s
  * `*mach` - mach number at exhaust
  * `o_f` - oxidizer/fuel weight ratio
  * `phi` - weight-based equivalence ratio of oxidizer/fuel
  * `ae` - Ratio of area at exit to area at throat.
    * `t_ae` - Ratio of area at throat to area at throat. Always 1 (exists because f_ae also exists, f_ae being ratio of combustor area to throat area)
  * `pip` - Ratio of pressure in chamber to pressure at exit
    * `t_ae` - Ratio of pressure in chamber to pressure at throat.

  Provided with this library is an interface to the thermo_spg.inp file provided with the library.
  You can access materials as if `ThermoInterface` is a dictionary using materials' CEA Names. E.G. `ThermoInterface["CH4"]`. This object support checking for inclusion and iterations, such as `"CH4" in ThermoInterface` and `for name in ThermoInterface`. It supports dictionary methods such as `.keys()`, `.values()` and `.items()`.
  The value returned by `ThermoInterface` accesses is a `ThermoMaterial object`, which is an `Output` object (dictionary that can be accessed with .dot notation) with the following keys:
  * `name` - Name of the material
  * `reference` - Reference, if given. Otherwise ""
  * `elements` - Dictionary of element: numerical value specified
  * `condensed` - True if condensed phase, False otherwise
  * `mw` - Molecular weight in g/mol
  * `hf` - float heat of formation at 298.15 in kJ/mol (or assigned enthalpy if 0 temp range)
  * `temp_ranges` - List of two-tuples of [range start, range end] (K)
  * `reactant_only` - True if material only shows up in reactants, False otherwise

  * `ThermoInterface.get_close_matches(name, [n])` - Gets close matches to a given material name. For example "Al(cr)" returns 'AL(cr)', 'ALN(cr)', 'Ag(cr)', 'W(cr)'. n influences the number of results returned, and is the maximum number of results returned.
  * `ThermoMaterial.defined_at(temp)` - Returns True if the material is specified at the given temperature, False otherwise. Materials specified at one temperature are actually allowed at that temperature +- 10K.

    ```open_thermo_lib()```
    Opens the default thermo library input file using the user's default .inp file viewer (should prompt if none)
    ```open_pdfs()```
    Opens the attached NASA pdfs using the user's default pdf viewer
    ```print_assets_directory()```
    Prints to console the current location of the directory where CEA_Wrap assets are located. Also returns this value
    ```print_simple_thermo_lib_line(name, comment, atoms, isCond, molWt, hf, temperature=298.15)```
    Returns and prints a string which can be inserted to represent a molecule in the Thermo Lib. Any entries which are longer than the allotted space results in an error
    * `name`: 24 chars max, Species name, such as CO or Fe2O3. These are assumed to be in a gas phase unless appended with (a) for agglomerate, (cr) for crystalline (solid), or (L) for liquid phase.
    * `comment`: 56 char max, Human-readable name and additional information
    * `atoms`: 5 atom max, A dictionary of "atomic symbol": number of atoms in molecule.
      Example: Water, "H2O", would be {"H": 2, "O": 1}
      Complex Example: Lead Acetate, "Pb(C2H3O2)2", would be {"Pb": 1, "C": 4, "H": 6, "O": 4}. Note that the C, H, and O are doubled because they are the *sum* of atoms in the molecule
      Note: "E" is a special value which represents an electron for ionic compounds. You can have negative amounts of "E" to indicate positively charged atoms
    * `isCond`: "Is Condensed?" True if the material is a solid or liquid, False if it is a gas.
    * `molWt`: Molecular weight of molecule in g/mol or kg/kmol
    * `hf`: Assigned Enthalpy of material at temperature specified. J/mol. If temperature=298.15K, this is the Heat of Formation.
    * `temperature`: Temperature that the molecule is specified at, Kelvin
    ```reload_thermo_lib()```
    Moves the thermo and transport libs from your assets directory (if they have changed) and reloads ThermoInterface from the thermo_spg.inp in your assets directory
    Use this if you have recompiled your thermo lib but do not want to restart python.
    Note: This is actually defined in CEA.py, not utils.py

    A DataCollector object will conveniently compile output from Problem outputs into list format. Example usage can be found in the "looping.py" example
    ```DataCollector(self, *args, keys=[], chamber_keys=[], throat_keys=[], exit_keys=[])```
  * `keys`: Also accepts list of arguments, these are keys such as 'cond' or 't_cp' or 'c_p'
  * `chamber_keys`: List of chamber species mol/mass fractions to be included in the output object. Ex: "H2O" or "CO2". The key in the ouptut will be the molecule name with "c_" prepended
  * `throat_keys`: List of nozzle throat species mol/mass fractions to be included. The key in the output will be the molecule name with "t_" prepended
  * `exit_keys`: List of nozzle exit species mol/mass fractions to be included. The key in the output will be the molecule name with nothing prepended.
    *Methods*
  * `add_data(data)` - Data should be the output from Problem.run(). Appends the output of the keys specified in the initializer to the object
  * `to_csv(filename, filename: str, keys:list=None, formatString="f"` - Writes the data to csv at **filename**, with the keys in **keys** (or all keys in this object if None)
       using **formatString** to format the csv entries

    You can add new molecules by modifying your thermo_spg.inp file and then recompiling the thermo lib.
    1. Find the location of your thermo_spg.inp file by using print_assets_directory()
    1. Open thermo_spg.inp in a text editor.
    1. Scroll to the bottom
    1. You can use print_simple_thermo_lib_line() to create a simple entry in the format of other reactants
    1. Add your entry below the other entries but above "END REACTANTS". Ensure your entry has similar spacing to existing entries
    1. To recompile your thermo lib, either use the "thermo_lib_recompile" batch file or run "FCEA2" and type "thermo_spg"
    1. If you have a python kernel open, you should now restart it or use the "reload_thermo_lib()" function to reload the thermo lib used.


pkgId: 74ea3d7b58e74c97c0017dfe5313829db1fda7ec5401d954efd76cade0bca07c
name: python-CEDApy
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/TerenceLiu98/CEDApy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CEDApy-0.3.6-1.src.rpm
checksum_type: sha256
description:
  ![py_version](https://img.shields.io/badge/python-3.6+-brightgreen)
  [![PyPI Version](https://img.shields.io/pypi/v/CEDApy.svg)](https://pypi.org/project/CEDApy)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5229506.svg)](https://doi.org/10.5281/zenodo.5229506)



  * "Centralized" means all-in-one, "all data" you need in one library
  * "Economic data" means economic data :)



  We have included multiple API for banks or statistics deparment of countries/region:

  * North America:
    - [x] `FredData` for [Fred Reserve Bank](https://fred.stlouisfed.org/)

  * Europe:
    - [x] `ECBData` for [European Central Bank](https://www.ecb.europa.eu/home/html/index.en.html)
    - [x] `EurostatData` for [European Statistics](https://ec.europa.eu/eurostat)

  * Asia:
    - [x] `NBSCData` for [National Bureau of Statistics of China](http://www.stats.gov.cn/english/)
    - [x] `XHData` for [Xinhua](https://www.cnfin.com/data/macro-data/index.html)
    - [x] `BOJData` for [Bank of Japan](https://www.boj.or.jp/en/index.htm/)



  We have two api for approaching the market data:

  - [x] `marketwatch` for [MarketWatch](https://www.marketwatch.com/)
  - [x] `dukascopy` for [Dukascopy Historial Data](https://www.dukascopy.com/swiss/english/marketwatch/historical/)

  *Recommandation is welcome! Tell us what data you need and we may put it into the to-do list :)*



  We also collect some interesting data which may useful in your reserach or project
  - [x] `EPU` for [Economic Policy Uncertainty](https://www.policyuncertainty.com/) and [Economic Policy Uncertainty in China](https://economicpolicyuncertaintyinchina.weebly.com/)



  Via the source code

  ```shell
  git clone https://github.com/TerenceLiu98/CEDApy.git
  python setup.py install
  ```

  Via the `pypi`:

  ```shell
  python -m pip install CEDApy
  ```



  Please check [Wiki](https://github.com/TerenceLiu98/CEDApy/wiki)



  * [St.Louis Federal Reserve Bank](https://fred.stlouisfed.org/), [Chicago Federal Reserve Bank](https://www.chicagofed.org/), [Philadelphia Federal Reserve Bank](https://www.philadelphiafed.org/)
  * [eurostat Economic Indicators](https://ec.europa.eu/eurostat/cache/infographs/economy/desktop/index.html)
  * [Europen Central Bank](https://www.ecb.europa.eu)
  * [National bureau of Statistics China](http://www.stats.gov.cn/english/)
  * [Bank of Japan](https://www.boj.or.jp/en/index.htm/)
  * [MarketWatch](https://www.marketwatch.com/)
  * [Dukascopy](https://www.dukascopy.bank/swiss)



  Here is a list for some related packages or tools that may help you finding the data you want:

  * [akshare](https://github.com/jindaxiang/akshare/) - an elegant and simple financial data interface library for Python, built for human beings
  * [tushare](https://github.com/waditu/tushare) - a utility for crawling historial data of China stocks
  * [investpy](https://github.com/alvarobartt/investpy) - Financial Data Extraction from Investing.com with Python



  ```txt
  @software{terencelau_2022_5915339,
    author       = {TerenceLau},
    title        = {TerenceLiu98/CEDApy: V0.3.0},
    month        = jan,
    year         = 2022,
    publisher    = {Zenodo},
    version      = {v0.3.0},
    doi          = {10.5281/zenodo.5915339},
    url          = {https://doi.org/10.5281/zenodo.5915339}
  }
  ```


pkgId: ca1d1e5c692a56158d3561b7cc5b4d49598b3cde8248f2f7868404064711e232
name: python-CEmu
arch: src
version: 0.8.0
epoch: 0
release: 1
url: https://github.com/hugsy/cemu
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CEmu-0.8.0-1.src.rpm
checksum_type: sha256
summary:
  Cemu is a simple assembly/dissembly/emulation IDE that provides an easy Plug-n-Play environment to start playing with many architectures (currently supports x86-{32,64}, ARM, AARCH64, MIPS, MIPS64, SPARC and PPC).

description:
  <p align="center">
    <img alt="Logo" src="src/cemu/img/new_logo.png" width=20%>
  </p>

  <h2 align="center">CEmu : The Cheap (Assembly) Emulator</h2>

  <p align="center">
    <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
    <a href="https://github.com/hugsy/cemu/blob/master/LICENSE"><img alt="Licence MIT" src="https://img.shields.io/packagist/l/doctrine/orm.svg?maxAge=2592000?style=plastic"></a>
    <img alt="Python-Version 3.10" src="https://img.shields.io/pypi/pyversions/cemu.svg">
    <a href="https://pypi.org/project/cemu/"><img alt="CEmu on PyPI" src="https://img.shields.io/pypi/v/cemu.svg"></a>
    <a href="https://discord.gg/qBn9MbG9vp"><img alt="CEmu on Discord" src="https://img.shields.io/badge/Discord-CEmu-green"></a>
    <a href="https://pepy.tech/project/cemu"><img alt="Downloads" src="https://static.pepy.tech/badge/cemu"></a>
  </p>




  Writing assembly is fun. Assembly is the lowest language (humanly understandable) available to communicate with computers, and is crucial to understand the internal mechanisms of any machine. Unfortunately, setting up an environment to write, compile and run assembly for various architectures (x86, ARM, MIPS, SPARC) has always been painful. **CEmu** is an attempt to fix this by providing GUI, CLI and library that allows to write and test assembly quickly.

  **CEmu** is built upon:
   * [Keystone](https://github.com/keystone-engine/keystone) for compiling assembly to bytecode
   * [Capstone](https://github.com/aquynh/capstone) for disassembling bytecode
   * [Unicorn](https://github.com/unicorn-engine/unicorn/) for the emulation

  And the GUI is powered by in a Qt6.

  It allows to test binary samples, check your shellcodes or even simply learn how to write assembly code, all of this for the following architectures:

    - x86-32 / x86-64
    - ARM / AArch64
    - MIPS / MIPS64
    - SPARC / SPARC64
    - PPC (but not emulation)

  `CEmu` was mostly tested to work on Linux and Windows, but should work on MacOS.




  __Notes__

  Since version 0.2.2, `cemu` is now Python3 only for simplicity and mostly also due to the fact that Python2 is not developed any longer. If your current installation of `cemu` is <= 0.2.1 and on Python2, please uninstall it and install it using Python3.

  In addition, Python >= 3.10 is required, starting `0.6`.




  Last stable from PyPI:

  ```bash
  pip3 install cemu
  ```

  Last stable from Github:

  ```bash
  git clone https://github.com/hugsy/cemu
  cd cemu
  pip3 install --upgrade .
  ```

  For 99% of cases, that's all you need to do. `cemu` will be installed in the associated `Scripts` directory:
   * On Linux by default the executable will be found as `/usr/local/bin/cemu` if installed as root, `~/.local/bin/cemu` for non-root
   * On Windows, `%PYTHON_DIR%\Scripts\cemu.exe` if installed with privileges, `%APPDATA%\Python\Python310\Scripts\cemu.exe` if not





  After installing with `pip`, simply run the executable, or invoke via Python

  ```bash
  python -m cemu
  ```

  This should produce a GUI similar to this:

  ![cemu-gui](src/cemu/img/cemu-windows-light.png)
  ![cemu-gui](src/cemu/img/cemu-windows-dark.png)



  ```bash
  python -m cemu cli
  ```

  From where you'll end up in a REPL, allowing you to build and run the emulation environment.

  ![cemu-cli](https://i.imgur.com/SyRJmI5.png)



  ```bash
  $ python
  >>> import cemu
  ```

  Then use the provided API to build and run your environment.



  `cemu` was created and maintained by myself, [`@_hugsy_`](https://twitter.com/_hugsy_), but kept fresh thanks to [all the contributors](https://github.com/hugsy/cemu/graphs/contributors).

  [ ![contributors-img](https://contrib.rocks/image?repo=hugsy/cemu) ](https://github.com/hugsy/cemu/graphs/contributors)

  If you just like the tool, consider dropping on Discord (or Twitter or other) a simple *"thanks"*, it is always very appreciated.
  And if you can, consider [sponsoring me](https://github.com/hugsy/sponsors) - it really helps dedicating time and resources to the projects!


pkgId: 7ee36aa2bba80605a9de680bdc6a2a5feba2ad870304164e689e2aa6072d4eee
name: python-CFSpy
arch: src
version: 1.0.13
epoch: 0
release: 1
summary: Chen-Fliess series computation
url: https://github.com/iperezav/CFSpy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CFSpy-1.0.13-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cfspy)][py-versions]
  [![PyPI - Version](https://img.shields.io/pypi/v/cfspy)][pypi-latest-version]
  ![PyPI - Status](https://img.shields.io/pypi/status/cfspy)
  [![PyPI - Downloads](https://img.shields.io/pypi/dd/cfspy)][downloads]
  [![PyPI - License](https://img.shields.io/pypi/l/cfspy)][license]
  </div>

  CFSpy is a package to simulate the output of a control system by means of the Chen-Fliess series.
  It provides:
  - The list of iterated integrals indexed by words of a certain length or less.
  - The list of Lie derivatives indexed by words of a certain length or less.
  - A single iterated integral indexed by a given word.
  - A single Lie derivative indexed by a given word.

  CFSpy is a Python library that contains the following functions:
  | Function | Description |
  | ---- | --- |
  | [**iter_int**](https://github.com/iperezav/CFSpy/blob/main/build/lib/CFS/iter_int.py) | A function for the numerical computation of a list of iterated integrals |
  | [**iter_lie**](https://github.com/iperezav/CFSpy/blob/main/build/lib/CFS/iter_lie.py) | A function for the analytical computation of a list of Lie derivatives |
  | [**single_iter_int**](https://github.com/iperezav/CFSpy/blob/main/build/lib/CFS/single_iter_int.py) | A function for the numerical computation of a single iterated integral |
  | [**single_iter_lie**](https://github.com/iperezav/CFSpy/blob/main/build/lib/CFS/single_iter_lie.py) | A function for the analytical computation of a single Lie derivative |
  CFSpy is used for:
  - Simulation of the output of a control systems.
  - Reachability analysis of a control system.

  Currently, `CFSpy` supports releases of Python 3.12.4 onwards.
  To install the current release:
  ```shell
  $ pip install --upgrade CFSpy
  ```


  ```python
  from CFS import iter_int, iter_lie, single_iter_int, single_iter_lie
  import numpy as np
  from scipy.integrate import solve_ivp
  import matplotlib.pyplot as plt
  import sympy as sp

  def system(t, x, u1_func, u2_func):
      x1, x2 = x
      u1 = u1_func(t)
      u2 = u2_func(t)
      dx1 = -x1*x2 +  x1 * u1
      dx2 = x1*x2 - x2* u2
      return [dx1, dx2]

  def u1_func(t):
      return np.sin(t)

  def u2_func(t):
      return np.cos(t)

  x0 = [1/3,2/3]

  t0 = 0
  tf = 3
  dt = 0.001
  t_span = (t0, tf)

  solution = solve_ivp(system, t_span, x0, args=(u1_func, u2_func), dense_output=True)

  t = np.linspace(t_span[0], t_span[1], int((tf-t0)//dt+1))
  y = solution.sol(t)

  x1, x2 = sp.symbols('x1 x2')
  x = sp.Matrix([x1, x2])

  g = sp.transpose(sp.Matrix([[-x1*x2, x1*x2], [x1, 0], [0, - x2]]))

  h = x1

  Ntrunc = 4

  Ceta = np.array(iter_lie(h,g,x,Ntrunc).subs([(x[0], 1/3),(x[1], 2/3)]))

  u1 = np.sin(t)
  u2 = np.cos(t)

  u = np.vstack([u1, u2])

  Eu = iter_int(u,t0, tf, dt, Ntrunc)

  F_cu = x0[0]+np.sum(Ceta*Eu, axis = 0)

  plt.figure(figsize = (12,5))
  plt.plot(t, y[0].T)
  plt.plot(t, F_cu, color='red', linewidth=5, linestyle = '--', alpha = 0.5)
  plt.xlabel('$t$')
  plt.ylabel('$x_1$')
  plt.legend(['Output of the system','Chen-Fliess series'])
  plt.grid()
  plt.show()
  ```
  <img src="https://raw.githubusercontent.com/iperezav/CFSpy/main/examples/output_chenfliess.png" alt="iter_int(), iter_lie()" />
  For more examples, see the [CFSpy demos](https://github.com/iperezav/CFSpy/blob/main/examples/)

  - [**PyPi**](https://pypi.org/project/CFSpy/)
  - [**Documentation**](https://github.com/iperezav/CFSpy/blob/main/README.md)
  - [**Issue tracking**](https://github.com/iperezav/CFSpy/issues)

  All feedback is welcome.

  Please reach out if you have any questions:
  1. [Github CFSpy discussions](https://github.com/iperezav/CFSpy/discussions/).
  2. [Github CFSpy issues](https://github.com/iperezav/CFSpy/issues).

  CFSpy is open-source and released under the [MIT License](LICENSE).

  Feel free to cite my work:
  ```bibtex
  @article{iperezave,
    title={CFSpy},
    author={Perez Avellaneda, Ivan},
    journal={GitHub. Note: https://github.com/iperezav/CFSpy},
    volume={1},
    year={2024}
  }
  ```
  [issues]: https://github.com/iperezav/CFSpy/issues
  [demos]: https://github.com/iperezav/CFSpy/blob/main/examples/
  [downloads]: https://pepy.tech/projects/cfspy
  [py-versions]: https://pypi.org/project/cfspy/
  [pypi-latest-version]: https://pypi.org/project/cfspy/
  [license]: https://github.com/iperezav/CFSpy/blob/main/LICENSE


pkgId: 8699a10e97afad4e5ce328ab0cce8b2218080be12a9a2f48761685f5d06dcaf1
name: python-CGDs
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Adaptive Competitive Gradient Descent optimizer
url: https://github.com/devzhk/cgds-package
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CGDs-0.4.5-1.src.rpm
checksum_type: sha256
description:
  `CGDs` is a package implementing optimization algorithms including three variants of [CGD](https://arxiv.org/abs/1905.12103)  in [Pytorch](https://pytorch.org/) with Hessian vector product and conjugate gradient.
  `CGDs` is for competitive optimization problem such as generative adversarial networks (GANs) as follows:
  $$
  \min_{\mathbf{x}}f(\mathbf{x}, \mathbf{y}) \min_{\mathbf{y}} g(\mathbf{x}, \mathbf{y})
  $$

  **Update**: ACGD now supports distributed training. Set `backward_mode=True` to enable. We have new member GMRES-ACGD that can work for general two-player competitive optimization problems.


  CGDs can be installed with the following pip command. It requires Python 3.6+.
  ```bash
  pip3 install CGDs
  ```
  You can also directly download the `CGDs` directory and copy it to your project.



  The `CGDs` package implements the following optimization algorithms with Pytorch:

  - `BCGD` : CGD algorithm in [Competitive Gradient Descent](https://arxiv.org/abs/1905.12103).
  - `ACGD` : ACGD algorithm in [Implicit competitive regularization in GANs](https://arxiv.org/abs/1910.05852).
  - `GACGD`: works for general-sum problem

  Quickstart with notebook: [Examples of using ACGD](https://colab.research.google.com/drive/1-52aReaBAPNBtq2NcHxKkVIbdVXdyqtH?usp=sharing).

  Similar to Pytorch package `torch.optim`, using optimizers in `CGDs` has two main steps: construction and update steps.

  To construct an optimizer, you have to give it two iterables containing the parameters (all should be `Variable`s).
  Then you need to specify the `device`, `learning rate`s.

  Example:
  ```python

  from src import CGDs
  import torch
  device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
  optimizer = CGDs.ACGD(max_param=model_G.parameters(), min_params=model_D.parameters(),
                        lr_max=1e-3, lr_min=1e-3, device=device)
  optimizer = CGDs.BCGD(max_params=[var1, var2], min_params=[var3, var4, var5],
                        lr_max=0.01, lr_min=0.01, device=device)
  ```



  Both two optimizers have `step()` method, which updates the parameters according to their update rules. The function can be called once the computation graph is created. You have to pass in the loss but do not have to compute gradients before `step()` , which is *different* from `torch.optim`.

  Example:

  ```python
  for data in dataset:
      optimizer.zero_grad()
      real_output = model_D(data)
     	latent = torch.randn((batch_size, latent_dim), device=device)
      fake_output = D(G(latent))
      loss = loss_fn(real_output, fake_output)
      optimizer.step(loss=loss)
  ```
  For general competitive optimization, two losses should be defined and passed to optimizer.step
  ```python
  loss_x = loss_f(x, y)
  loss_y = loss_g(x, y)
  optimizer.step(loss_x, loss_y)
  ```



  Please cite it if you find this code useful.

  ```latex
  @misc{cgds-package,
    author = {Hongkai Zheng},
    title = {CGDs},
    year = {2020},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/devzhk/cgds-package}},
  }
  ```


pkgId: 3e4d7450c04af6e262c783982d52005b6da2a375d4203a692dc96c836bd43424
name: python-CHAID
arch: src
version: 5.4.2
epoch: 0
release: 1
summary: A CHAID tree building algorithm
url: https://github.com/Rambatino/CHAID
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CHAID-5.4.2-1.src.rpm
checksum_type: sha256
description:
  This package provides a python implementation of the Chi-Squared Automatic Inference Detection (CHAID) decision tree


pkgId: 679c27768f46a1c2a063097db274f44d4c9e66d8072e2189ea74807d70df961d
name: python-CHESS-python-nightly
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Clustered Hierarchical Entropy-Scaling Search
url: https://github.com/nishaq503/CHESS
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CHESS-python-nightly-1.1.0-1.src.rpm
checksum_type: sha256
description:
  CHESS is a search algorithm for large data sets when the data exhibits certain geometric properties.

  All classes and functions are very well documented in the code. If you want more details, read them.
  The [paper](https://arxiv.org/pdf/1908.08551.pdf) is available on the arXiv.

  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/nishaq503/CHESS.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/nishaq503/CHESS/context:python)
  [![codecov](https://codecov.io/gh/thoward27/chess/branch/master/graph/badge.svg)](https://codecov.io/gh/thoward27/chess)
  [![Documentation Status](https://readthedocs.org/projects/clustered-hierarchical-entropy-scaling-search/badge/?version=latest)](https://clustered-hierarchical-entropy-scaling-search.readthedocs.io/en/latest/?badge=latest)



  Download this repository...

  ```bash
  git clone https://github.com/nishaq503/CHESS.git
  ```


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


  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: ce3b352b8cadecc0d0c0c8b6cf78463fdddbc1a42b556301bc17db33cda61143
name: python-CHSPy
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Cubic Hermite splines
url: https://pypi.org/project/CHSPy/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CHSPy-1.2.2-1.src.rpm
checksum_type: sha256
description:
  This module provides Python tools for cubic Hermite splines with one argument (time) and multiple values.
  It was branched of from [JiTCDDE](http://github.com/neurophysik/jitcdde), which uses it for representing the past of a delay differential equation.

  You can find the documentation [on Read the Docs](https://chspy.readthedocs.io).


pkgId: b2e044062a0bcd4b398ec6099dfd493e6c6e49633578af222ad1f38c76e4099f
name: python-CI-CloudConnector
arch: src
version: 4.4
epoch: 0
release: 1
description: Created by
url: https://trunovate.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CI-CloudConnector-4.4-1.src.rpm
checksum_type: sha256
summary:
  IOT application that collects data from PLC (ModBus or AnB Ethernet/IP) and sends it to the cloud using HTTPS


pkgId: 82154d2520b6f425d216f7379d5498348f0cd52c8cf509c94e95214f9f8e656a
name: python-CI-methods-analyser
arch: src
version: 1.1.0.post1
epoch: 0
release: 1
summary: Analyse efficacy of your own confidence interval (CI) methods
url: https://github.com/Kukuster/CI_methods_analyser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CI-methods-analyser-1.1.0.post1-1.src.rpm
checksum_type: sha256
description:
  A toolkit for measuring the efficacy of various methods for calculating a confidence interval.
  Currently provides a toolkit for measuring the efficacy of methods for a confidence interval for the following statistics:

   - proportion
   - the difference between two proportions

  This library was mainly inspired by the library:
  ["Five Confidence Intervals for Proportions That You Should Know About" by Dr. Dennis Robert](https://towardsdatascience.com/five-confidence-intervals-for-proportions-that-you-should-know-about-7ff5484c024f)


   - python >=3.8
   - python libs:
      - numpy
      - scipy
      - matplotlib
      - tqdm



  **Applied statistics and data science:** compare multiple CI methods to select the most appropriate for specific scenarios (by its accuracy at a specific range of true population properties, by computational performance, etc.)

  **Education on statistics and CI:** demonstrates how different CI methods perform under various conditions, helps to understand the concept of CI by comparing methods for evaluation of accuracy of CI methods






  Wald Interval is defined as so:

  <div style="text-align: center; margin: auto">
      <img style="display: inline-block; margin: 5px" src="https://latex.codecogs.com/png.latex?%5Cbg_white%20%28w%5E-%2C%20w%5E&plus;%29%20%3D%20%5Chat%7Bp%7D%5C%2C%5Cpm%5C%2Cz%5Csqrt%7B%5Cfrac%7B%5Chat%7Bp%7D%281-%5Chat%7Bp%7D%29%7D%7Bn%7D%7D" alt="$$ (w^-, w^+) = p\,\pm\,z\sqrt{\frac{p(1-p)}{n}} $$" />
  </div>

  How well does it approximate the confidence interval?

  Let's assess what would be the quality of produced 95%CI with this method by testing on a range of proportions. We'll take 100 true proportions, with 1% step `[0.001, 0.011, 0.021, ..., 0.991]`.


  ```python
  from CI_methods_analyser import CImethodForProportion_efficacyToolkit as toolkit, methods_for_CI_for_proportion

  toolkit(
      method=methods_for_CI_for_proportion.wald_interval, method_name="Wald Interval"
  ).calculate_coverage_and_show_plot(
      sample_size=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95,
      plt_figure_title="Wald Interval coverage"
  )


  input('press Enter to exit')
  ```


  This outputs the image:

  ![Wald Interval - real coverage](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/wald_interval_p_0.001_0.999_0.01_n100_conf95.png)

  The plot indicates the overall bad performance of the method and particularly poor performance for extreme proportions. While for some true proportions the calculated CI has true confidence of around 95%, most of the time the confidence is significantly lower. For the true proportions of <0.05 and >0.95 the true confidence of the generated CI is generally lower than 90%, as indicated by the steep descent on the left-most and right-most parts of the plot.

  <hr>

  *You really might want to use a different method. Check out this wonderful medium.com article by **Dr. Dennis Robert**:*
   - ***[Five Confidence Intervals for Proportions That You Should Know About](https://towardsdatascience.com/five-confidence-intervals-for-proportions-that-you-should-know-about-7ff5484c024f)** [code in R]*

  <hr>

  <br>

  The function `calculate_coverage_and_show_plot` that we just used is a shortcut. The code below does the same calculations and yields the same result. It relies on the public properties and methods, giving more control over parts of the calculation:

  ```python
  from CI_methods_analyser import CImethodForProportion_efficacyToolkit as toolkit, methods_for_CI_for_proportion


  wald_interval = methods_for_CI_for_proportion.wald_interval


  wald_interval_test_toolkit = toolkit(
      method=wald_interval, method_name="Wald Interval")




  wald_interval_test_toolkit.calculate_coverage_analytically(
      sample_size=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95)







  wald_interval_test_toolkit.plot_coverage(
      plt_figure_title="Wald Interval coverage")




  wald_interval_test_toolkit.show_plot()



  input('press Enter to exit')
  ```

  I expose some style/color settings used by matplotlib.

  My preference goes to the **night light-friendly** styling:

  ```python
  from CI_methods_analyser import CImethodForProportion_efficacyToolkit as toolkit, methods_for_CI_for_proportion


  toolkit(
      method=methods_for_CI_for_proportion.wald_interval, method_name="Wald Interval"
  ).calculate_coverage_and_show_plot(
      sample_size=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95,
      plt_figure_title="Wald Interval coverage",
      theme='dark_background', plot_color="green", line_color="orange"
  )


  input('press Enter to exit')
  ```

  ![Wald Interval - real coverage (dark theme)](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/wald_interval_p_0.001_0.999_0.01_n100_conf95_dark.png)




  <br>



  You can implement your own methods and test them:

  ```python
  from CI_methods_analyser import CImethodForProportion_efficacyToolkit as toolkit
  from CI_methods_analyser.math_functions import normal_z_score_two_tailed
  from functools import lru_cache


  @lru_cache(100_000)
  def im_telling_ya_test(x: int, n: int, conflevel: float = 0.95):
      z = normal_z_score_two_tailed(conflevel)

      p = float(x)/n
      return (
          p - 0.02*z,
          p + 0.02*z
      )


  toolkit(
      method=im_telling_ya_test, method_name='"I\'m telling ya" test'
  ).calculate_coverage_and_show_plot(
      sample_size=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95,
      plt_figure_title='"I\'m telling ya" coverage',
      theme='dark_background', plot_color="green", line_color="orange"
  )


  input('press Enter to exit')

  ```
  !["I'm telling ya" test - real coverage](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/im_telling_ya_test_p_0.001_0.999_0.01_n100_conf95_dark.png)


  This is the kind of test one would not trust. It shows very unreliable performance for the majority of the true proportions, as indicated by an extremely high discrepancy between the "ordered" confidence level of 95% and the true confidence of the CI range provided by this method. This means the output CIs are generally smaller than should be, therefore there's less confidence that the true value lies within the range of a CI. One could say, this method overestimates its ability to generate a confident range.

  <b>Let's try another custom method: "God is my witness" score</b>

  ```python
  from CI_methods_analyser import CImethodForProportion_efficacyToolkit as toolkit
  from CI_methods_analyser.math_functions import normal_z_score_two_tailed
  from functools import lru_cache


  @lru_cache(100_000)
  def God_is_my_witness_score(x: int, n: int, conflevel: float = 0.95):
      z = normal_z_score_two_tailed(conflevel)

      p = float(x)/n
      return (
          (0 + p)/2 - 0.005*z,
          (1 + p)/2 + 0.005*z
      )


  toolkit(
      method=God_is_my_witness_score, method_name='"God is my witness" score'
  ).calculate_coverage_and_show_plot(
      sample_size=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95,
      plt_figure_title='"God is my witness" score coverage', theme='dark_background'
  )

  input('press Enter to exit')
  ```

  !["God is my witness" score - real coverage](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/God_is_my_witness_score_p_0.001_0.999_0.01_n100_conf95_dark.png)


  This method clearly overdid the estimates. While one expects 95%CI, the output range is less clear, as it allows for a very wide range of possibilities. In a stats lingo one would say that this method is way too conservative.




  Let's use the implemented **Pooled Z test**:

  <div style="text-align: center; margin: auto">
      <img style="display: inline-block; margin: 5px" src="https://latex.codecogs.com/gif.latex?%5Cbg_white%20%28%5Cdelta%5E-%2C%20%5Cdelta%5E&plus;%29%20%3D%20%5Chat%7Bp%7D_T%20-%20%5Chat%7Bp%7D_C%20%5Cpm%20z_%7B%5Calpha%7D%5Csqrt%7B%5Cbar%7Bp%7D%281-%5Cbar%7Bp%7D%29%28%5Cfrac%7B1%7D%7Bn_T%7D&plus;%5Cfrac%7B1%7D%7Bn_C%7D%29%7D" alt="$$ (\delta^-, \delta^+) = \hat{p}_T - \hat{p}_C \pm z_{\alpha}\sqrt{\bar{p}(1-\bar{p})(\frac{1}{n_T}+\frac{1}{n_C})} $$" />
  </div>
  , where:
  <div style="text-align: center; margin: auto">
      <img style="display: inline-block; margin: 5px" src="https://latex.codecogs.com/gif.latex?%5Cbg_white%20%5Cbar%7Bp%7D%20%3D%20%5Cfrac%7Bn_T%5Chat%7Bp%7D_T%20&plus;%20n_C%5Chat%7Bp%7D_C%7D%7Bn_T%20&plus;%20n_C%7D" alt="$$ \bar{p} = \frac{n_T\hat{p}_T + n_C\hat{p}_C}{n_T + n_C} $$" />
  </div>


  ```python
  from CI_methods_analyser import CImethodForDiffBetwTwoProportions_efficacyToolkit as toolkit_d, methods_for_CI_for_diff_betw_two_proportions as methods


  toolkit_d(
      method=methods.Z_test_pooled, method_name='Z test pooled'
  ).calculate_coverage_and_show_plot(
      sample_size1=100, sample_size2=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95,
      plt_figure_title='Z test pooled', theme='dark_background',
  )

  input('press Enter to exit')
  ```


  ![Z test (unpooled) - real coverage](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/z_test_pooled_p_0.001_0.999_0.01_n1_100_n2_100_conf95.png)

  As you can see, this test is generally perfect for close proportions (along `y = x` line) <b>[WHITE]</b>, unless proportions have extreme values, where confidence of the outputted CIs is lower than expected <b>[PURPLE]</b>

  Also, this test is extremely conservative for the high and extreme differences between two proportions, i.e. for proportions whose values are far apart <b>[GREEN]</b>

  <br>


  You may want to change the color palette (although I wouldn't):


  ```python
  from CI_methods_analyser import CImethodForDiffBetwTwoProportions_efficacyToolkit as toolkit_d, methods_for_CI_for_diff_betw_two_proportions as methods


  toolkit_d(
      method=methods.Z_test_pooled, method_name='Z test pooled'
  ).calculate_coverage_and_show_plot(
      sample_size1=100, sample_size2=100, proportions=('0.001', '0.999', '0.01'), confidence=0.95,
      plt_figure_title='Z test pooled', theme='dark_background',
      colors=("gray", "purple", "white", "orange", "#d62728")
  )

  input('press Enter to exit')
  ```

  ![Z test (unpooled) - real coverage](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/z_test_pooled_p_0.001_0.999_0.01_n1_100_n2_100_conf95_hotcolors.png)


  <br>
  <br>




  Two ways can be used to calculate the efficacy of CI methods for a given confidence and a true population proportion:
   - approximately, with random simulation (as implemented in R by Dr. Dennis Robert, see link above). Here: `calculate_coverage_randomly`.
   - precisely, with the analytical solution. Here: `calculate_coverage_analytically`

  <b>By default, always prefer the analytical solution.</b>

  Sampling the same binomial distribution n times, as it's typically done, (called "random experiments", or "simulations") is inefficient, because the binomial distribution is already fully determined by the given true population proportion.

  By relying on the binomial distribution from scipy, the analytical solution provides 100% accuracy for any method (defined as a python function), any confidence level, any true population proportion(s), any sample and population size(s).

  Mathematical proof of the analytical solution:

  ![Proof of the analytical solution](https://github.com/Kukuster/CI_methods_analyser/raw/master/docs/2021-05-08_ci-method-for-proportions_analytical-solution.jpg)


  Both "simulation" and "analytical" methods are implemented for CI for both statistics: *proportion*, and *the difference between two proportions*. For the precise analytical solution, an optimization was made. Theoretically, it is lossy, but practically, the error is always negligible (as shown by `test_z_precision_difference.py`) and is less significant than a 64-bit floating point precision error between the closest `float` representation and the true `Real` value. Optimization is regulated with the parameter `z_precision`, which is automatically estimated by default.



  <br>


  **1. Equivalence and Noninferiority Testing (as I understand, are fancy terms for 2-sided and 1-sided p tests for the difference between two proportions)**
   - **[https://ncss-wpengine.netdna-ssl.com/wp-content/themes/ncss/pdf/Procedures/PASS/Confidence_Intervals_for_the_Difference_Between_Two_Proportions.pdf](https://ncss-wpengine.netdna-ssl.com/wp-content/themes/ncss/pdf/Procedures/PASS/Confidence_Intervals_for_the_Difference_Between_Two_Proportions.pdf)**
   - **[https://ncss-wpengine.netdna-ssl.com/wp-content/themes/ncss/pdf/Procedures/PASS/Non-Inferiority_Tests_for_the_Difference_Between_Two_Proportions.pdf](https://ncss-wpengine.netdna-ssl.com/wp-content/themes/ncss/pdf/Procedures/PASS/Non-Inferiority_Tests_for_the_Difference_Between_Two_Proportions.pdf)**
   - [https://www.ncss.com/wp-content/themes/ncss/pdf/Procedures/NCSS/Two_Proportions-Non-Inferiority,_Superiority,_Equivalence,_and_Two-Sided_Tests_vs_a_Margin.pdf](https://www.ncss.com/wp-content/themes/ncss/pdf/Procedures/NCSS/Two_Proportions-Non-Inferiority,_Superiority,_Equivalence,_and_Two-Sided_Tests_vs_a_Margin.pdf)
   - [https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3019319/](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3019319/)
   - [https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2701110/](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2701110/)
   - [https://pubmed.ncbi.nlm.nih.gov/9595617/](https://pubmed.ncbi.nlm.nih.gov/9595617/)
   - [http://thescipub.com/pdf/10.3844/amjbsp.2010.23.31](http://thescipub.com/pdf/10.3844/amjbsp.2010.23.31)

  **2. Biostatistics course (Dr. Nicolas Padilla Raygoza, et al.)**
   - [https://docs.google.com/presentation/d/1t1DowyVDDRFYGHDlJgmYMRN4JCrvFl3q/edit#slide=id.p1](https://docs.google.com/presentation/d/1t1DowyVDDRFYGHDlJgmYMRN4JCrvFl3q/edit#slide=id.p1)
   - [https://www.google.com/search?q=Dr.+Sc.+Nicolas+Padilla+Raygoza+Biostatistics+course+Part+10&oq=Dr.+Sc.+Nicolas+Padilla+Raygoza+Biostatistics+course+Part+10&aqs=chrome..69i57.3448j0j7&sourceid=chrome&ie=UTF-8](https://www.google.com/search?q=Dr.+Sc.+Nicolas+Padilla+Raygoza+Biostatistics+course+Part+10&oq=Dr.+Sc.+Nicolas+Padilla+Raygoza+Biostatistics+course+Part+10&aqs=chrome..69i57.3448j0j7&sourceid=chrome&ie=UTF-8)
   - [https://slideplayer.com/slide/9837395/](https://slideplayer.com/slide/9837395/)

  **3. Using z-test instead of a binomial test:**
   - When can use [https://stats.stackexchange.com/questions/424446/when-can-we-use-a-z-test-instead-of-a-binomial-test](https://stats.stackexchange.com/questions/424446/when-can-we-use-a-z-test-instead-of-a-binomial-test)
   - How to use [https://cogsci.ucsd.edu/~dgroppe/STATZ/binomial_ztest.pdf](https://cogsci.ucsd.edu/~dgroppe/STATZ/binomial_ztest.pdf)


pkgId: 1ad8fc42077ff04d14e970d3bba09ca6f8f72eac0cd12fc12df4feb53d8a8e5b
name: python-CIBer
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A Comonotone-Independence Bayesian Classifier
url: https://github.com/ross1456/CIBer-Package.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CIBer-0.1.3-1.src.rpm
checksum_type: sha256
description:
  This package is an implementation of:<br />
  Paper: Comonotone-Independence Bayes classifier (CIBer)  <br />
  Author: Yongzhao CHEN, Ka Chun CHEUNG, Nok Sang FAN, Suresh SETHI, and Sheung Chi Phillip YAM

  This is the user guide for Comonotone-Independence Bayesian Classifier (CIBer). CIBer is a supervised learning model which deals with multi-class classification tasks. The continuous feature variables are discretized and those categorical ones are encoded via the proposed **Joint Encoding**.

  This document mainly explain the important and practical functions in **CIBer.py** and **CIBer_Engineering.py**. Lastly, the **CIBer_Bankchurner.ipynb** gives a simple but illuminating example on CIBer with the use of [Bankchurner](https://www.kaggle.com/code/thomaskonstantin/bank-churn-data-exploration-and-churn-prediction/data) dataset by Thomas Konstantin. Please refer to original author [Kaiser's Repository](https://github.com/kaiser1999/CIBer) for details.


  The **MDLP** discretization method has been disabled, you need to install package manually since it requires additional tools.

  Step1: install c/c++ tools<br />

  install visual studio community, and then install [**Microsoft C++ Build Tools**](https://visualstudio.microsoft.com/visual-cpp-build-tools/) for C/C++ related packages


  type the following line in terminal to install the **Command Line Tools package**
  >xcode-select --install

  Step2:
  type the following line in terminal to install

  ```
  pip install mdlp-discretization
  ```

  ```
  pip install git+https://github.com/hlin117/mdlp-discretization
  ```
  refer to author [hlin117's repository](https://github.com/hlin117/mdlp-discretization/tree/master/mdlp)



  CIBer deals with multi-class classification tasks with numerical or discrete (but should be ordered) input variables. Before passing the data into the model, please perform some proper data preprocessing beforehand, e.g. removals of outlier and missing observation, and encode all categorical feature variables with numerical values.




  To use CIBer:
  ```
  from CIBer import CIBer
  ```

  > init(self, cont_col=[], asso_method='modified', min_asso=0.95, alpha=1, disc_method="norm", joint_encode=True, **kwargs)

  **_cont_col_**: a list, containing the indices of the continuous variables

  **_asso_method_**: a string can be set to "pearson", "spearman", "kendall", "modified". Four measurements to correlation. The default is "modified"

  **_min_asso_**: a number between $0,1$ which specifies the threshold of correlation when determining the comonotonic relationship. The default value is 0.95

  **_alpha_**: a positive number used in Laplacian smoothing. The default value is 1

  **_joint_encode_**: a boolean, whether to use joint encoding. The default value is True

  **_disc_method_**: a string indicating the discretization method adopted for each continuous feature variable. The default string is "norm" for normal distribution quantile method

  **_**kwargs_**: additional keyworded arguments passing to **Discretization()**, below are two acceptable keyworded arguments

  **_n_bins_**: a positive integer for the total number of bins for each discretization.

  **_disc_backup_**: a string indicating the discretization method adopted if the method **_disc_method="mdlp"_** fails.

  > fit(self, x_train, y_train)

  **_x_train_**: a numpy $n \times p$ array for the $p$ training (real-valued) feature variables with $n$ training observations

  **_y_train_**: a numpy $n \times 1$ array for the $n$ training (real-valued) labels

  > predict(self, x_test)

  **_x_test_**: a numpy $n \times p$ array for the $p$ test (real-valued) feature variables with $n$ test observations

  **return**: a numpy $n \times 1$ array for the $n$ predicted class labels

  > predict_proba(self, x_test)

  **_x_test_**: a numpy $n \times p$ array for the $p$ test (real-valued) feature variables with $n$ test observations

  **return**: a numpy $n \times K$ array for the predicted probabilities of the $K$ classes with $n$ test observations


  > self.cluster_book
  a Python dictionary where
  1. keys: class label
  2. vals: lists of clusters, each of which contains the indices of feature variables within the same cluster, generated by the AGNES algorithm. If there is only one integer value in a given list, then the corresponding feature variable is seen to be independent to all other feature variables given the class label. Otherwise, they are modelled by conditional comonotonicity given the class label.

  > self.distance_matrix_
  a numpy $p \times p$ array, where the $(i,j)$ entry is the corresponding association value computed according to the chosen **_asso_method_** of feature $i$ and feature $j$.



  > Discretization(cont_col, disc_method, disc_backup="pkid", n_bins=10)

  **_cont_col_**: a list of indices to be discretized

  **_disc_method_**: any string in **DISC_BASE** + **SCIPY_DIST**, (refer to CIBer.py)

  list of distributions provided by scipy used in Equal-quantile distribution method, number of bins determined by **_n_bins_**
  > SCIPY_DIST = ["uniform", "norm", "t", "chi2", "expon", "laplace", "skewnorm", "gamma"]

  list of common discretiztion methods for Na\"ive Bayes classifier
  > SIZE_BASE = ["equal_size", "pkid", "ndd", "wpkid"]

  list of all discretization methods except **SCIPY_DIST**
  > DISC_BASE = ["equal_length", "auto"] + SIZE_BASE

  list of alternative discretization methods if mdlp fails except **SCIPY_DIST**
  > MDLP_BACKUP = ["equal_length", "auto"] + SIZE_BASE

  **return** a class for discretization method



  > init(self, df, col_index)

  **_df_**: a $n \times p$ dataframe for $p$ feature variables of $n$ observations

  **_col_index_**: a list, containing the indices of categorical feature variables

  > fit(self, x_train)

  **_x_train_**: a $n \times p$ numpy array for the $p$ training feature variables with $n$ training observations

  > transform(self, x_test)

  **_x_test_**: a numpy $n \times p$ array for the $p$ test (real-valued) feature variables with $n$ test observations

  **return**: a numpy $n \times p$ array with the encoded categorical feature variable


pkgId: d65c195ab7df81b3da4300f87483b500b587d6e342f948818f50cc5bcab2d097
name: python-CIRIquant
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: circular RNA quantification pipeline
url: https://github.com/bioinfo-biols/CIRIquant
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CIRIquant-1.1.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/bioinfo-biols/CIRIquant.svg?branch=master)](https://travis-ci.com/bioinfo-biols/CIRIquant)
  ![GitHub release (latest by date)](https://img.shields.io/github/v/release/bioinfo-biols/CIRIquant)
  [![The MIT License](https://img.shields.io/badge/license-MIT-orange.svg)](https://github.com/bioinfo-biols/CIRIquant/blob/master/LICENSE)
  ![GitHub All Releases](https://img.shields.io/github/downloads/bioinfo-biols/CIRIquant/total)
  ![SourceForge](https://img.shields.io/sourceforge/dm/ciri/CIRIquant)
  [![Documentation Status](https://readthedocs.org/projects/ciri-cookbook/badge/?version=latest)](https://ciri-cookbook.readthedocs.io/en/latest/?badge=latest)

  CIRIquant is a comprehensive analysis pipeline for circRNA detection and quantification in RNA-Seq data



  Documentation is available online at [https://ciri-cookbook.readthedocs.io/en/latest/](https://ciri-cookbook.readthedocs.io/en/latest/CIRIquant_0_home.html#)



  Authors: Jinyang Zhang(zhangjinyang@biols.ac.cn), Fangqing Zhao(zhfq@biols.ac.cn)

  Maintainer: Jinyang Zhang



  - Version 1.1: Added support for stranded library and GFF3 format input.
  - Version 1.0: The first released version of CIRIquant.



  The code is released under the MIT License. See the `LICENSE` file for more detail.



  - Zhang, J., Chen, S., Yang, J. et al. Accurate quantification of circular RNAs identifies extensive circular isoform switching events. Nat Commun 11, 90 (2020) [doi:10.1038/s41467-019-13840-9](https://doi.org/10.1038/s41467-019-13840-9)


pkgId: 332375dadd17fa7591f575f7b60862328469d9410e60ffa5dd798af24edaeb17
name: python-CITeX
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Tools to manage large BibTex libraries
url: https://github.com/HealthHackAu2016/cbr-improved-citations
rpm_license: GPL3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CITeX-0.2.2-1.src.rpm
checksum_type: sha256
description:
  CITeX searches through BibTeX files to search and remove duplicate entries.  It does this by comparing parsed titles strings and for simple cases, it then groups by similarities computes scores and selects the best single citation from that group of duplicates.
  This project was a part of HealthHack 2016 in Canberra.
  **Authors**: Aqeel Akber, Michael Barson, Sam Blackwell, Zac Hatfield-Dodds, Andrea Parisi


pkgId: 331dd0d8c4a6224a6141a973dce0109d6308f97e93f5a45c04a6199bc0e7e00d
name: python-CJKwrap
arch: src
version: 2.2
epoch: 0
release: 1
summary: CJKwrap is a library for wrapping and filling CJK text. Fix Python issue24665
url: https://fgallaire.github.io/cjkwrap
rpm_license: GNU LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CJKwrap-2.2-1.src.rpm
checksum_type: sha256
description:
  **CJKwrap** is a library for wrapping and filling CJK text.
  CJKwrap fix the issue24665 because Python 2 will stay broken forever:
  https://bugs.python.org/issue24665.
  CJKwrap support **both** Python 2 (2.6 and above) and Python 3 (3.3 and above).
  CJKwrap is developed by Florent Gallaire fgallaire@gmail.com.
  Website: http://fgallaire.github.io/cjkwrap.


pkgId: c977831214fe0ca4c994040e2eac15b149ea50a3d8638a5ffbf16fe154ac096e
name: python-CLAM
arch: src
version: 3.2.10
epoch: 0
release: 1
url: https://proycon.github.io/clam
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CLAM-3.2.10-1.src.rpm
checksum_type: sha256
summary:
  Turns command-line tools into fully-fledged RESTful webservices with an auto-generated web-interface for human end-users.


pkgId: 835217b4f598797c7ee8b90a5ad276b1da4a2af936c02241397f47086b7d8868
name: python-CLAMServices
arch: src
version: 2.2.3
epoch: 0
release: 1
summary: A collection of CLAM Webservices for various of our NLP tools
url: https://proycon.github.io/clam
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CLAMServices-2.2.3-1.src.rpm
checksum_type: sha256
description:
  This is a collection of CLAM webservices (i.e. RESTful wesbervices powered by CLAM,
  https://proycon.github.io/clam) for various Natural Language Processing
  tools.  These webservices are hosted on https://webservices-lst.science.ru.nl .
  CLAM webservices for the following tools are supplied here:
  * `Frog <https://languagemachines.github.io/frog>`_
  * `Ucto <https://languagemachines.github.io/ucto>`_
  * `Timbl <https://languagemachines.github.io/timbl>`_
  * `Colibri Core <https://proycon.github.io/colibri-core>`_
  * `Alpino <http://www.let.rug.nl/vannoord/alp/Alpino/>`_
  * `SpaCy <https://spacy.io>`_ (with added FoLiA support)
  The tools themselves are not in this repository and need to be installed
  separately, we recommend to use our `LaMachine <https://proycon.github.io/LaMachine>`_
  distribution which contains everything at once.
  To install these CLAM webservices manually, clone this repository and run:
  ``python setup.py install``


pkgId: 297db0e17e9498f37dc6974b7920d2f1f03ff4bf832765adf4b312a37480cab5
name: python-CLIbrary
arch: src
version: 1.10.0
epoch: 0
release: 1
url: https://github.com/diantonioandrea/CLIbrary
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CLIbrary-1.10.0-1.src.rpm
checksum_type: sha256
summary:
  A comprehensive Python library of standard CLI utilities for convenient command, I/O, and file handling.

description:
  ![PyPI](https://img.shields.io/pypi/v/CLIbrary)
  ![GitHub last commit](https://img.shields.io/github/last-commit/diantonioandrea/CLIbrary)
  ![GitHub Release Date](https://img.shields.io/github/release-date/diantonioandrea/CLIbrary)



  A comprehensive Python library of standard CLI utilities for convenient command, I/O, and file handling.

  **CLIbrary** is a comprehensive Python library that makes command line usage, input/output, and file handling easier and more efficient. *It provides a wide range of tools for interacting with a shell*, including essential utilities for *command line parsing and I/O, file manipulations, tab completion, and command hinting*. With these tools, **CLIbrary** makes it easy to integrate powerful command-line functionality into any Python project.
  Additionally, it now also provides a *history feature for tracking and re-executing previous commands*.

  Make sure to take a look at the [documentation](https://github.com/diantonioandrea/CLIbrary/blob/main/docs/docs.md), at the [contributing guidelines](https://github.com/diantonioandrea/CLIbrary/blob/main/.github/CONTRIBUTING.md) and at the [examples](#examples).





  **CLIbrary** can be installed from [PyPI](https://pypi.org) by:

  	python3 -m pip install --upgrade CLIbrary



  The installation of **CLIbrary** can be verified by:

  	python3 -m CLIbrary

  which would return something similar to[^1]:

  	 ●  CLIbrary v1.7.2
  	A comprehensive Python library of standard CLI utilities for convenient command, I/O, and file handling.
  	Developed by Andrea Di Antonio, more on https://github.com/diantonioandrea/CLIbrary
  	Documentation on https://github.com/diantonioandrea/CLIbrary/blob/main/docs.md
  	Bug tracker on https://github.com/diantonioandrea/CLIbrary/issues

  [^1]: Example referring to version 1.7.2



  **CLIbrary** can be imported by:

  	import CLIbrary



  These are some examples from existing projects[^2].



  An example from [**openTree**](https://github.com/diantonioandrea/openTree)

  ``` python
  import CLIbrary

  ...

  cmdHandler = {"request": "[" + user.name + "@" + name + "]"}
  cmdHandler["style"] = Fore.MAGENTA

  cmdHandler["helpPath"] = helpPath

  ...

  cmdHandler["allowedCommands"] = ["set", "password", "delete", "new"]

  ...

  command = CLIbrary.cmdIn(cmdHandler)

  cmd = command["command"]
  sdOpts = command["sdOpts"]
  ddOpts = command["ddOpts"]
  ```

  [^2]: "..." indicates missing code.



  Some examples from [**openBriefcase**](https://github.com/diantonioandrea/openBriefcase)

  ```python
  import CLIbrary

  ...

  class account:
  	def __init__(self, otherNames: list):
  		self.name = CLIbrary.strIn({"request": "Account name", "space": False, "blockedAnswers": otherNames})
  		self.start = CLIbrary.numIn({"request": "Starting balance"})

  ...

  class movement:
  	def __init__(self, otherCodes: list):
  		...

  		self.reason = CLIbrary.strIn({"request": "Movement reason", "allowedChars": ["-", "'", ".", ",", ":"]})
  		self.amount = CLIbrary.numIn({"request": "Movement amount"})
  		self.date = CLIbrary.dateIn({"request": "Movement date"})

  		...

  		self.confirmation = CLIbrary.boolIn({"request": "Verify \"" + str(self) + "\""})
  ```



  An example from [**openTree**](https://github.com/diantonioandrea/openTree)

  ``` python
  import CLIbrary

  ...

  user = openTree.user()

  fileHandler = {"path": dataPath + user.name, "ignoreMissing": True}
  userData = CLIbrary.aLoad(fileHandler)

  ...

  fileHandler["data"] = user
  CLIbrary.aDump(fileHandler)
  ```



  An example from [**openTree**](https://github.com/diantonioandrea/openTree)

  ``` python
  import CLIbrary

  ...

  CLIbrary.data.setting_fileExtension = ".ot"

  ...

  if userData.darkTheme:
  	CLIbrary.style.setting_darkMode = True
  ```


pkgId: b5289adf342aaad1d679f16c97a8b8ad0782ed5c6dbf9b359215a8e00764c5f5
name: python-CMakeLintBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'CMakeLintBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CMakeLintBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CMakeLintBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Check CMake code for syntactical or formatting issues.

      For more information consult <https://github.com/richq/cmake-lint>.


pkgId: 4fbd501ed64bf02a3630ce7a04048b518cc89ca6a098b86cfeb5422ac9b291cc
name: python-CMinx
arch: src
version: 1.1.11
epoch: 0
release: 1
summary: Documentation Generator for the CMake Language
url: https://pypi.org/project/CMinx/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CMinx-1.1.11-1.src.rpm
checksum_type: sha256
description:
  ..
     Copyright 2021 CMakePP

     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.


  CMinx


  .. image:: https://codecov.io/gh/CMakePP/CMinx/branch/master/graph/badge.svg?token=wbiPq8Gnrs
     :target: https://codecov.io/gh/CMakePP/CMinx

  .. image:: https://joss.theoj.org/papers/10.21105/joss.04680/status.svg
     :target: https://doi.org/10.21105/joss.04680


  Full documentation can be found `here <https://cmakepp.github.io/CMinx/>`__.

  *****************
  Statement of Need
  *****************

  CMake build systems can be extended by writing CMake modules. CMake modules
  typically consist of one or more functions (or macros) written in the CMake
  language. In an effort to treat infrastructure as code, we need to be able to
  generate API documentation for these CMake modules. CMinx addresses this need
  by generating reStructuredText files from documented CMake modules. Since CMinx
  understands the grammar of the CMake language, these comments only need to focus
  on describing the code and not duplicating it.

  *************************
  Installation Instructions
  *************************

  The easiest way to install CMinx is via ``pip``. Simply run:

  .. code:: .py

     pip install CMinx


  CMinx can also easily be used as part of a CMake workflow by adding:

  .. code-block:: cmake

     include(FetchContent)
     FetchContent_Declare(
         cminx
         GIT_REPOSITORY https://github.com/cmakepp/cminx.git
     )
     FetchContent_MakeAvailable(cminx)
     cminx_gen_rst("${input_dir}" "${output_dir}")

  to your ``CMakeLists.txt`` file. More detailed instructions, can be found
  `here <https://cmakepp.github.io/CMinx/installation.html>`__.


  *************
  Example Usage
  *************

  To use CMinx, first document your CMake modules like:

  .. code:: cmake

     
     
     
     
     
     
     
     
     function(example param0)
         message("This function says: ${param0}")
     endfunction()

  The documentation resides in a normal CMake block comment aside from the fact
  that the block comment starts with an extra ``[`` character. The body of the
  block comment is extracted into the reStructuredText file more or less verbatim
  so reStructuredText markup can be used within the comment for more formatting
  options. Assuming the above CMake module lives in ``example.cmake``, the
  API documentation is generated by running:

  .. code:: console

     foo@bar:~$ cminx example.cmake

  Which will generate:

  .. code:: reStructuredText

     
     example
     

     .. module:: example


     .. function:: example(param0)

        A brief description.

        A more detailed description, must be separated from the brief by at least
        one blank line.

        :param param0: The 0-th parameter passed to the function

  See `here <https://cmakepp.github.io/CMinx/documenting/index.html>`__ for more
  detailed usage instructions.


  *****************
  API Documentation
  *****************

  Full API documentation can be found
  `here <https://cmakepp.github.io/CMinx/developer/api.html>`__.

  ************
  Contributing
  ************

  In short, we try to be a welcoming community. If you have questions,
  suggestions, bug reports, *etc.* open an issue and we will address them
  as soon as possible. If you want to contribute code, that's even better. We
  recommend you start a draft PR early in the process so we know the contribution
  is coming and can help you along the way.

  CMinx is part of the CMakePP organization, whose contributing guidelines can be
  found `here <https://github.com/CMakePP/.github/blob/main/CONTRIBUTING.md>`__.

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


pkgId: be79141d69d141e946ff4c741ec16f0b67b723e108c1ac004a0cd380b488e7c7
name: python-CNFgen
arch: src
version: 0.9.3.post1
epoch: 0
release: 1
summary: CNF formula generator
url: https://massimolauria.net/cnfgen
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CNFgen-0.9.3.post1-1.src.rpm
checksum_type: sha256
description:
  This repository provides the command

  - `cnfgen` formula generator;

  and the following python scripts, designed to operate from/to dimacs
  CNFs:

  - `cnfshuffle` random shuffler;

  You  can get  a  brief help  on  how  to use  these  tools by  running
  `<program_name> --help` from the command line.

  Run `cnfgen --help` to get a list of the implemented formula families.
  To get  more specific information  on one  class of formula  use the
  command

      cnfgen <formula_type> --help



  - Webpage of the project at <http://massimolauria.net/cnfgen/>
  - Technical documentation <https://cnfgen.readthedocs.io/en/latest/>
  - Python Package at <https://pypi.org/project/CNFgen/>
  - Github repository <https://github.com/MassimoLauria/cnfgen>
  - Zenodo link (DOI) <https://zenodo.org/record/3548843>


  Copyright 2012-2020  © Massimo
  Lauria ([massimo.lauria@uniroma1.it](mailto:massimo.lauria@uniroma1.it))


pkgId: 66f7f949df079a58a2bfb5b59d9b151f9558186b24e11d6d3c1b365368dac519
name: python-CNSeq2TimeSpan
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: This is a tool for converting chinese time phrases into time spans.
url: https://github.com/QixinLi/Time_NLP
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CNSeq2TimeSpan-0.1.9-1.src.rpm
checksum_type: sha256
description:
  此项目基于[zhanzecheng的Time_NLP](https://github.com/zhanzecheng/Time_NLP),并增添了时间域的输出。


  ```shell script
  pip install CNSeq2TimeSpan
  ```


  ```python
  from CNSeq2TimeSpan.TimeNormalizer import TimeNormalizer
  tn = TimeNormalizer()

  res = tn.parse(target=u'今年的财务报表交了吗')
  print(res)

  res = tn.parse(target=u'昨天刚写完，明天早上就交')
  print(res)
  ```
  返回结果
  ```json
  {
  	'timebase': '2019-11-21-15-3-58',
  	'word': ['今年'],
  	'type': 'timespan',
  	'timespan': [
  		['2019-01-01 00:00:00', '2019-12-31 23:59:59']
  	]
  }

  {
  	'timebase': '2019-11-21-8-3-58',
  	'word': ['昨天', '明天早上'],
  	'type': 'timespan',
  	'timespan': [
  		['2019-11-20 00:00:00', '2019-11-20 23:59:59'],
  		['2019-11-21 06:00:00', '2019-11-21 09:00:00']
  	]
  }
  ```


  Time-NLP的python3版本
  python 版本https://github.com/sunfiyes/Time-NLPY
  Java 版本https://github.com/shinyke/Time-NLP


  demo：python3 Test.py

  优化说明

  | 问题          | 以前版本                                     | 现在版本                    |
  | ----------- | ---------------------------------------- | ---------------------- |
  | 无法解析下下周末     | "timestamp": "2018-04-01 00:00:00"                                    | "timestamp": "2018-04-08 00:00:00"                 |
  | 无法解析 3月4         | "2018-03-01"                                   | "2018-03-04"               |
  | 无法解析 初一 初二      | cannot parse                                    | "2018-02-16"              |
  | 晚上8点到上午10点之间  无法解析上午      | ["2018-03-16 20:00:00", "2018-03-16 22:00:00"] |  ["2018-03-16 20:00:00", "2018-03-16 10:00:00"]|
  | 3月21号  错误解析成2019年      | "2019-03-21" | "2018-03-21" |

  感谢@[tianyuningmou](https://github.com/tianyuningmou) 目前增加了对24节气的支持


      temp = ['今年春分']
      "timestamp" : "2020-03-20 00:00:00"



  | 问题          | 现在版本                                     | 正确
  | ----------- | ---------------------------------------- | ---------------------- |
  | 晚上8点到上午10点之间     |  ["2018-03-16 20:00:00", "2018-03-16 22:00:00"] |  ["2018-03-16 20:00:00", "2018-03-17 10:00:00"]"                                    | "timestamp": "2018-04-08 00:00:00"                 |


pkgId: ef3a53ccee1afc97e548dee97605831bfe2024ad38b117f7eacf5309f6a28c8c
name: python-CO2Signal
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: A package to access the co2signal API
url: https://github.com/danielsjf/CO2Signal
rpm_license: Creative Commons Attribution-Noncommercial-Share Alike license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CO2Signal-0.4.2-1.src.rpm
checksum_type: sha256
description:
  A package to access the co2signal API.

  Using this package, you can query the latest CO2 intensity in all the countries or regions, available in https://www.electricitymap.org. The package uses the API available via https://co2signal.com. The intensity can be queried using the code below.

  ```python
  import CO2Signal

  token = "get yours from co2signal.com"


  CO2Signal.get_latest_carbon_intensity(token, country_code='BE')


  CO2Signal.get_latest_carbon_intensity(token, longitude=50, latitude=5)
  ```


pkgId: 8cc016423467d2afcc9c215213219a5c86d204e569b5bf6363749a71509a7b7d
name: python-COBY
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Build coarse-grained molecular systems
url: https://pypi.org/project/COBY/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-COBY-0.2.2-1.src.rpm
checksum_type: sha256
description:
  The paper is currently in pre-print at [bioRxiv](https://www.biorxiv.org/content/10.1101/2024.07.23.604601v1).

  The program as well as documentation and a tutorial is avialable on the [GitHub](https://github.com/MikkelDA/COBY).

  COBY is a Python-based software for building flat membranes in coarse-grained resolution. It handles asymmetric membranes, phase-separated systems, multiple bilayers, protein insertion, solvation and flooding with one or multiple solute molecules of choice.

  COBY is versatile, fast, easy-to-use and it also allows for high-level of customisation. It can be used either as a **Python package** or directly from the **terminal command line**. It neatly handles multiple parameter libraries (even within the same system), making it developer-friendly.

  COBY is continuously under development and we welcome suggestions for new features.

  ![](https://github.com/MikkelDA/COBY/raw/master/figures/COBY_Logo.png)


  ```
  @article {Andreasen2024COBY,
  	author = {Andreasen, Mikkel D. and Souza, Paulo C. T. and Schi{\o}tt, Birgit and Zuzic, Lorena},
  	title = {Creating Coarse-Grained Systems with COBY: Towards Higher Accuracy in Membrane Complexity},
  	elocation-id = {2024.07.23.604601},
  	year = {2024},
  	doi = {10.1101/2024.07.23.604601},
  	publisher = {Cold Spring Harbor Laboratory},
  	URL = {https://www.biorxiv.org/content/early/2024/07/23/2024.07.23.604601},
  	eprint = {https://www.biorxiv.org/content/early/2024/07/23/2024.07.23.604601.full.pdf},
  	journal = {bioRxiv}
  }
  ```



  **Using pip (requires python>=3.9)**

      conda create --name COBY python==3.9 ipykernel

      conda activate COBY

      pip install COBY

      python -m ipykernel install --user --name=COBY

  Ipykernel allows the user to use COBY environment within the Jupyter notebook.



  For a detailed introduction to the software, please consult [COBY Documentation](https://github.com/MikkelDA/COBY/blob/master/COBY_Documentation.pdf).

  For a quick reminder of available commands, you can use the [Cheat Sheet](https://github.com/MikkelDA/COBY/blob/master/COBY_CHEAT_SHEET.pdf).

  Three [tutorials](https://github.com/MikkelDA/COBY/tree/master/Tutorial) are available as Jupyter Notebooks, one covering the basics, another covering more advanced functionalities and the final covering the systems shown in our soon-to-be released paper.

  The tutorials includes (amongst other systems):

  * **Simple membrane with protein**: A simple POPC membrane with a protein in solvent (water + 0.15 M NaCl) which explains the various arguments in COBY
  * **Asymmetric membrane**: An asymmetric complex membrane (POPC, POPE and CHOL) in solvent with different area per lipid values for each membrane
  * **Phase separated Membrane**: A phase separated membrane
  * **Monolayers**: Two monolayers with solvent between them and vacuum over the pbc
  * **Nanodisc**: A nanodisc with DMPC lipid contained within and with solvent surrounding it
  * **Holes**: A membrane with multiple manually defined holes
  * **Patches**: Multiple manually shaped membrane patches
  * **Matryoshka membrane**: A matryoshka membrane with a protein in the center
  * **Stacked membranes**: Three vertically stacked membranes
  * **Mixed solvent**: A symmetric membrane solvated with regular and small water beads in specified ratios
  * **Phase separated solvent**: A symmetric membrane solvated with two solvent volumes containing different salt concentrations
  * **Flooding of imported solutes**: A membrane system that has been flooded with imported solute molecules, followed by solvation
  * **COBY logo**: Our logo



  COBY is preserved under the [Apache License 2.0](https://github.com/MikkelDA/COBY/blob/main/LICENSE).

  ![](https://github.com/MikkelDA/COBY/raw/master/figures/membrane_protein.png)


pkgId: c1a4e5aec737350986fe05f040dc01f9cfe71f29650aa8b9d28a8ceea3d7d6f7
name: python-COMPREDICT-AI-SDK
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Connect Python applications with COMPREDICT AI Core.
url: https://github.com/compredict/ai-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-COMPREDICT-AI-SDK-2.1.1-1.src.rpm
checksum_type: sha256
description:
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/COMPREDICT-GmbH/ai-sdk-python/ai-sdk-python)
  ![GitHub release (latest by date)](https://img.shields.io/github/v/release/COMPREDICT-GmbH/ai-sdk-python)
  [![PyPI](https://img.shields.io/pypi/v/COMPREDICT-AI-SDK?color=orange)](https://pypi.org/project/COMPREDICT-AI-SDK/)
  **Python client for connecting to the COMPREDICT V2 REST API.**
  **To find out more, please visit** **[COMPREDICT website](https://compredict.ai/ai-core/)**.


pkgId: dead841e9a728c2570cb77dfeef44c512abd72b8d97f2e52ed5a8d74930100f8
name: python-COWBAT
arch: src
version: 0.5.0.23
epoch: 0
release: 1
summary: CFIA OLC Workflow for Bacterial Assembly and Typing
url: https://github.com/OLC-Bioinformatics/COWBAT
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-COWBAT-0.5.0.23-1.src.rpm
checksum_type: sha256
description:
  ![alt text](cowbat.png "Cowbat")





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


pkgId: 22792d30e150049f6f86abd07e6ae420b034fb13a8713e0bedc87579e04ae536
name: python-CPAT
arch: src
version: 3.0.5
epoch: 0
release: 1
summary: CPAT (Coding Potential Assessment Tool).
url: https://pypi.org/project/CPAT/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CPAT-3.0.5-1.src.rpm
checksum_type: sha256
rpm_license:
  CPAT is distributed under GNU General Public License  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA


pkgId: edb112903fc48b940007d87bb6052a065749e8b44fdaf9e8734d0c2203205722
name: python-CPPCheckBear
arch: src
version: 0.10.0.1482010155
epoch: 0
release: 1
summary: 'CPPCheckBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CPPCheckBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CPPCheckBear-0.10.0.1482010155-1.src.rpm
checksum_type: sha256
description:
  Report possible security weaknesses for C/C++.
  For more information, consult <https://github.com/danmar/cppcheck>.


pkgId: 9dc2533840ede42c6598067bcc784a2f38298b2beae8e91c0d50c1a564a1c5e9
name: python-CPPLintBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'CPPLintBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CPPLintBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CPPLintBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Check C++ code for Google's C++ style guide.

      For more information, consult <https://github.com/theandrewdavis/cpplint>.


pkgId: 849765011dd2fa10005cdf87f8bcc12c82795942c7360307af2f04e4efda7f68
name: python-CPT-GFFParser
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: A Biopython extension package for I/O of GFF files
url: https://pypi.org/project/CPT-GFFParser/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CPT-GFFParser-1.2.2-1.src.rpm
checksum_type: sha256
description:
  An extensively featured Python parser for GFF format reading and writing


  - [Changelog](#Changelog)
  - [Need](#Need)
  - [Goals](#Goals)
  - [Release](#Release)
  - [Library Contents](#library-contents)
    - [CPT_GFFParser.gffParse](#CPT_GFFParsergffParse)
    - [CPT_GFFParser.gffWrite](#CPT_GFFParsergffWrite)
    - [gffSeqFeature.gffSeqFeature](#gffseqfeaturegffseqfeature)
    - [gffSeqFeature.convertSeqRec](#gffseqfeatureconvertSeqRec)
    - [gffSeqFeature.convertSeqFeat](#gffseqfeatureconvertSeqFeat)
  - [Credit](#Credit)
  - [Contact Us](#contact-us)


  1.0.0 - Initial release

  1.2.0 - Better handling of Is_circular features, removal of UnknownSeq in favor of BioPython's new Seq-based method. Requires Biopython 1.79 or greater


  The Center for Phage Technology uses the Generic Feature Format extensively in our analysis, and Biopython is the most extensively integrated library within our own codebase. Unfortunately, the GFF format is not directly supported by Biopython, and as development of that project continued, we were no longer able to find an acceptable community solution to our need to support the GFF format. We encountered 2 main obstacles to implementing outside solutions:
  1. Biopython compatibility
     - It was imperative that any solution be able to interact cleanly with Biopython, as requiring extensive work to be done on the input would require rewrites across most of our codebase. However, Biopython has made significant changes over the years to its structure, and community solutions unfortunately had not kept pace. Additionally, as legacy versions of Biopython were cycled out of distribution, we could no longer rely on simply not upgrading as an ad-hoc solution,as losing our local copies of the packages could result in disaster.
  2. Galaxy Compatibility
     - Most of the CPT's work is done on our instance of the Galaxy Project environment. Our Galaxy install distributes resources across local area machines and within one-off, limited permission environments. While there were more up-to-date GFF solutions out there, they also relied on a more concrete assumption of permanence and less finnicky writing permissions. We required a highly portable solution that was ambivalent about its working environment.


  Given a lack of available solutions, the decision was made to develop our own GFF library for parsing and writing out the format.
  1. Be a portable, light-weight, memory-only solution to reading in and writing out GFF format files.
     - A Python library was a proven solution in the context of our other work.
  2. Interface directly with SeqRecord and other Biopython structures to require minimal work on our main scripting files to be compatible.
     - Our prior solution had been BCBio's GFF functions. These generally used arrays of SeqRecord objects as their input arguments and output.
     - With this in mind, upon release, the overwhelming number of our tools were able to be made compatible simply by changing the import line, and replacing previous function names with gffParse and gffWrite. After tests on an intial batch of tools, the rest were successfully made compatible with nothing more than bash commands.
  3. Related to the above, clean replacement of BCBio was desired, with minimal need to change assumptions about input arguments and especially without a need to change the XML structure of our existing Galaxy tools.
     - For the parser, this was done by maintaining that the first input was the GFF file handle, and the second, optional input was a dictionary object indexed on Organism ID that had SeqRecord objects as their value.
     - Similarly, the writer accepts the Biopython objects first, and then a writable handle or stream.
     - However, it should be noted that this is not an extension of BCBio; this code is not derived from that project, and a deliberate effort was made to not inspect their repository so as to avoid any influence. This is made without any claim either way as to quality, but our needs require an actively developed solution. We are grateful to Blue Collar Bioinformatics for their work, which sustained us all the way to 2020.
  4. More cleanly integrate aspects of the GFF format into existing Biopython based solutions.
     - The SeqFeature object and related constructs are very useful programming tools. Unfortunately, one major recent change to the library was to deprecate the sub_features functionality, in favor of using Compound Locations.
     - While this reasoning is sound for formats Biopython directly supports, such as Genbank, it was less applicable to GFF3, which has heirarchy extremely baked into the concept, and more importantly for our needs, prior code has assumed a heirarchichal relationship between related features, of a wide array of types.
     - Therefore, we decided to create a subclass of SeqFeature, gffSeqFeature, which reimplemented sub_features and could still be passed along as an array to unmodified SeqRecord objects. Additionally, guaranteed-present attributes, such as phase and score (Which are dedicated columns in the GFF spec) were added as attributes, rather than relying on equivalent qualifiers, which may be lost in the course of other bioinformatic work.
  5. Finally, create a parser that is robust and informative at diagnosing failures and informing the user as to what went wrong.
     - A frequent demand from our users is validation scripts, to be run on datasets to ensure they conform to some kind of spec before doing extensive work and possibly wasting that time if the initial data is poorly structured.
     - We desired to extend this experience to the parser, and create a tool that, as best as possible, could withstand reading in improperly formatted GFF files until the EOF, and output a comprehensive list of problematic lines and their errors. It hoped that the errorlog this program creates will have enough information that the user will only need to go back for one round of changes.


  gffParse and gffWrite were initially released at the end of Summer, 2020 on the CPT Galaxy server, effective across all of our tools interfacing with GFF files. Thanks to the testing and patience of our users and students, it was a mostly stable library by the end of September, and almost fully featured by that November. February 2021 marks the most recent round of feature implementation, primarily focused on metadata features and metadata directives the GFF spec names pragmas (The initial release supported the ##FASTA pragma, but the others were not deemed a priority at the time). Additionally, in anticipation of a public standalone release, more arguments were added to the primary IO functions in order to help users fit the tool to their own needs. For example, the CPT frequently finds it highly useful in our workflow to strip as much metadata as possible, however we have now implemented a variety of options for writing out and dynamically creating metadata features and annotations if desired.



  The primary function for reading in GFF files. Will return a list of SeqRecord objects, with gffSeqFeature objects as their .feature lists.

  `gffParse(gff3In, base_dict = {}, outStream = sys.stderr, codingTypes=["CDS"], metaTypes = ["remark"], suppressMeta = 2, pragmaPriority = True, pragmaOverridePriority = True):`
  - gff3In --- source file handle, will accept any object that implements a .readlines() method or other list-like access to file lines
  - base_dict --- Additional SeqRecord information. Keys are OrganismIDs and values are SeqRecords. For BCBio backwards compatibility.
  - outStream --- output filestream or stringstream for the errorlog to be passed, if any parsing errors are encountered
  - codingTypes --- list of feature types where a non-'.' phase value is expected, passed along to lineAnalysis
  - metaTypes --- list of metadata feature types. Features of this type will be affected by the remaining arguments
  - suppressMeta --- Suppress metadata fields. Integer value, where:
    - 0 == no suppression, all metadata from features and pragmas will be read and output to the SeqRecord as .annotation entries.
    - 1 == As above, but metadata features will not be entered into the SeqRecord's feature list after their metadata is recorded and entered into the SeqRecord.annotation
    - 2 == Total suppression, no metadata features will even be processed, and no pragmas except those related to sequence length (##FASTA and ##sequence-region) and ##gff-version (required by GFF spec) will be utilized.
  - pragmaPriority --- In cases where pragmas and metadata features disagree/conflict, pragmas will take precedence for creating SeqRecord.annotation value if true, else the feature will.
  - pragmaOverridePriority --- Similar to above, in the event of a conflict between metadata features and pragmas, the pragma's value will override the metadata gffSeqFeature.qualifier value with the pragma's own. This will force the metadata and pragmas to sync, and avoid future discrepancies. Should only be used with pragmaPrority also set to True


  The primary function for writing out GFF files.

  `gffWrite(inRec, outStream = sys.stdout, suppressMeta = 1, suppressFasta=True, codingTypes = ["CDS"], metaTypes = ["remark"], validPragmas = None, recPriority = True, createMetaFeat=None)`
  - inRec --- The input, can either be one SeqRecord object or a list of them. Expects the features to be of gffSeqFeature type, if working with a vanilla Biopython record (For example, after having used SeqIO to read in a Genbank file), please see `gffSeqFeature.convertSeqRec` below.
  - outStream --- The output location, can be a file handle, stringstream, or anything else with a .write method implemented.
  - suppressMeta --- Suppress metadata fields. Integer value, where:
    - 0 == no suppression, all metadata from features of a type in metaTypes and annotations from SeqRecord.annotation will be read and output to the GFF as ##pragma entries, where the key will be the pragma and the values will be joined by " " and output on the same line (newlines replaced by " ").
    - 1 == As above, but metadata features will not be written out to file after their annotation information is retrieved.
    - 2 == Total suppression, no metadata features or SeqRecord.annotations will even be processed, and no pragmas or metadata features will be in the final output. The two exceptions are at least one ##gff-version pragma will be created at the first line, as per the GFF spec requirements, and if a FASTA is supplied and suppressFasta is set to False, a ##FASTA directive and corresponding sequence(s) will be created at the end of the file.
  - suppressFasta --- If True, do not write the Fasta sequences of this SeqRecord list at the end of the GFF
  - codingTypes --- A list of feature types where an integer is expected in the phase field, even if that integer would be the default value of 0. Features of types not in this list will have their phase written as the default "." empty value IF their .phase is 0.
  - metaTypes --- A list of feature types that are metadata information. Features of these types will have their qualifiers counted as annotations, and they will be affected by the actions of suppressMeta above.
  - validPragmas --- A whitelist of pragmas to output, in cases where some, but not all, annotations would be desired. Setting to None will allow allow all annotations. Setting to empty list will allow no annotations (Except as discussed above in suppressMeta, where #gff-version and ##FASTA are compulsory). Note that this affects pragmas only, and metadata *features* will not be affected by a choice here.
  - recPriority --- In cases where a SeqRecord.annotation and a qualifier in a metadata feature conflict, the SeqRecord will take priority if set to true, otherwise the metadata feature will.
  - creatMetaFeat --- A string input, where if it is set to None then no metadata feature will be created, otherwise a metadata feature of that type will be created, and all annotations wil be written out as its qualifiers. For example, createMetaFeat="remark" will cause a feature of type remark to be created with appropriate FeatureLocation and qualifiers. If there already exists a feature of that type in the output, then that feature will simply be updated.


  A subclass of SeqFeature. Minimal editing has been done to it, so it should still be largely compatible with any operations that are done on a regular SeqFeature. However the sub_features property has been reimplemented, so care must be taken that analysis done on "top-level" features cascades down to sub-features, if need be. See the documentation on Biopython's SeqFeature for most needs, only the differences are discussed here:

  `gffSeqFeature(SeqFeature.SeqFeature):
      def __init__(self, location=None, type="", location_operator="", strand=None, id="<unknown id>", qualifiers=None, sub_features=None, ref=None, ref_db=None, phase=0, score=0.0, source="feature"):`
  Three new fields have been appended, phase, score, and source, columns 8, 6, and 2 respectively in GFF output. All three can be accessed as .properties of a gffSeqFeature object. Additionally, sub_features will now accept a list of gffSeqFeatures as input, rather than informing the user this feature has been deprecated.

  `    def _shift(self, offset):`
  Behaves identically to \_shift in a SeqFeature object, but reimplemented because the output has to be explicitly cast as a gffSeqFeature.

  `    def translate(self, parent_sequence, table="Standard", start_offset=None, stop_symbol="*", to_stop=False, cds=None, gap=None):`
  Behaves identically to regular SeqFeature, except the .phase property is checked along with seeing if there's a codon_start qualifier. start_offset will still override both, and codon_start will take precedence over .phase


  A function for converting the members of a SeqRecord's SeqFeature list into gffSeqFeature objects. Will output a list of SeqRecord objects. If your input file was not a GFF then you probably want to run this before sending your SeqRecord to gffWrite. Will attempt to pair "source", "codon_start", "score" and "Parent" qualifiers in a SeqFeature with the appropriate gffSeqFeature property.

  As long your SeqFeature objects have "Parent" qualifiers whose value corresponds to the .id property of another SeqFeature in the list, then it will correctly construct a heirarchy. Note that this script will fail if you construct a series of features that parent each other in a loop or cycle, or if you create a feature who lists itself as a Parent (self-loop). These qualifiers are allowed in Biopython because there is no formal heirarchy, but GFF must enforce it.

  `convertSeqRec(inRec, defaultSource = "gffSeqFeature", deriveSeqRegion = True, createMetaFeat = None):`
  - inRec --- A seqRecord or list of SeqRecords to have their features converted.
  - defaultSource --- A string input for the source field of the gffSeqFeature (column 2 in GFF output). If a "source" qualifier is present in the feature, that will be used instead.
  - deriveSeqRegion --- If True, the script will derive a ##sequence-region pragma/annotation based off of the "largest" FeatureLocation.end encountered while reading the features in. It will then add this key/value to the SeqRecord.annotation dictionary.
  - createMetaFeat --- A string input, where if it is set to None then no metadata feature will be created, otherwise a metadata feature of that type will be created, and all annotations wil be written out as its qualifiers. For example, createMetaFeat="remark" will cause a feature of type remark to be created with appropriate FeatureLocation and qualifiers. If there already exists a feature of that type in the output, then that feature will simply be updated.


  Primarily used by gffSeqFeature.convertSeqRec, but can be accessed as a standalone function if there is a need to convert only individual features detached from a SeqRecord object.

  `convertSeqFeat(inFeat, defaultSource = "gffSeqFeature"):`
  - inFeat --- A single FeatureLocation object
  - defaultSource --- If there is no "source" qualifier in this feature's qualifiers, this string will be set as the source (column 2 in GFF output)


  Center for Phage Technology,
  Anthony Criscione, 2020-2021

  Distributed under the BSD 3-Clause license, included in the LICENSE file of this same directory

  gffSeqFeature developed in accordance with the Biopython License Agreement, and similarly licensed under the BSD 3-Clause License


  For issues directly related to coding errors or other library problems, we encourage you to submit an issue via the issues tab above. Please provide relevant information such as error messages, function arguments, and input data.

  For other inquiries, contact info for the Center for Phage Technology can be found at cpt.tamu.edu


