# packages

pkgId: eefb133193fe94d76aa13e7556b813e8d1ac55ea18f7124f1b3cf3b63a887222
name: python-chime-frb-api
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: CHIME/FRB API
url: https://github.com/CHIMEFRB/frb-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chime-frb-api-4.0.2-1.src.rpm
checksum_type: sha256
description:
  `chime-frb-api` is a python library to access CHIME/FRB backend. This library enables you interact with resources such as databases, event headers, calibration products, cluster jobs etc.
  Check out the **[documentation](https://chimefrb.github.io/frb-api/)** for more details.

  The latest stable version is available on [PyPI](https://pypi.org/project/chime-frb-api/).
  To install `chime-frb-api` simply run,
  ```bash
  pip install --upgrade chime-frb-api
  ```
  To add `chime-frb-api` to your project,
  ```bash
  poetry add chime-frb-api
  ```

  For further reading, please refer to the [documentation](https://chimefrb.github.io/frb-api/).


pkgId: a5cd0b0cf1f59d0e6458bd7277c245dd79d38cdd63c455bea2a5c83b0f4b6a2b
name: python-chinese-calendar
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: check if some day is holiday in China
url: https://github.com/LKI/chinese-calendar
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinese-calendar-1.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Package](https://img.shields.io/pypi/v/chinesecalendar.svg)](https://pypi.python.org/pypi/chinesecalendar)
  [![Travis](https://img.shields.io/travis/LKI/chinese-calendar.svg)](https://travis-ci.org/LKI/chinese-calendar)
  [![License](https://img.shields.io/github/license/LKI/chinese-calendar.svg)](https://github.com/LKI/chinese-calendar/blob/master/LICENSE)
  [![README](https://img.shields.io/badge/README-English-brightgreen.svg)](https://github.com/LKI/chinese-calendar/blob/master/README.en.md)

  判断某年某月某一天是不是工作日/节假日。
  支持 2004年 至 2025年，包括 2020年 的春节延长。



  ```
  pip install chinesecalendar
  ```



  ```
  pip install -U chinesecalendar
  ```

  由于次年的节假日安排，取决于国务院发布的日程。
  所以本项目一般会在国务院更新以后，发布新的版本。
  按照以往的经验，一般是每年的 11月 前后发布新版本。



  ``` python
  import datetime


  from chinese_calendar import is_holiday, is_workday
  april_last = datetime.date(2018, 4, 30)
  assert is_workday(april_last) is False
  assert is_holiday(april_last) is True


  import chinese_calendar as calendar  # 也可以这样 import
  on_holiday, holiday_name = calendar.get_holiday_detail(april_last)
  assert on_holiday is True
  assert holiday_name == calendar.Holiday.labour_day.value


  import chinese_calendar
  assert chinese_calendar.is_in_lieu(datetime.date(2006, 2, 1)) is False
  assert chinese_calendar.is_in_lieu(datetime.date(2006, 2, 2)) is True
  ```



  假如你没法使用Python，
  你也可以转译现成的[常量文件][constants.py]来获取最全的节假日安排表。



  1. Fork + Clone 项目到本地
  2. 修改[节假日定义][scripts/data.py]
  3. 执行[脚本][scripts/__init__.py]自动生成[常量文件][constants.py]
  4. 提交PR

  [constants.py]: https://github.com/LKI/chinese-calendar/blob/master/chinese_calendar/constants.py
  [scripts/data.py]: https://github.com/LKI/chinese-calendar/blob/master/chinese_calendar/scripts/data.py
  [scripts/__init__.py]: https://github.com/LKI/chinese-calendar/blob/master/chinese_calendar/scripts/__init__.py


pkgId: 6c026f6c11ae22b0051a348ce238b120160ba6d5554f26ec519e0702f56b36d2
name: python-chinese-calendar
arch: src
version: 1.9.2
epoch: 0
release: 1
summary: check if some day is holiday in China
url: https://github.com/LKI/chinese-calendar
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinese-calendar-1.9.2-1.src.rpm
checksum_type: sha256
description:
  [![Package](https://img.shields.io/pypi/v/chinesecalendar.svg)](https://pypi.python.org/pypi/chinesecalendar)
  [![Travis](https://img.shields.io/travis/LKI/chinese-calendar.svg)](https://travis-ci.org/LKI/chinese-calendar)
  [![License](https://img.shields.io/github/license/LKI/chinese-calendar.svg)](https://github.com/LKI/chinese-calendar/blob/master/LICENSE)
  [![README](https://img.shields.io/badge/README-English-brightgreen.svg)](https://github.com/LKI/chinese-calendar/blob/master/README.en.md)

  判断某年某月某一天是不是工作日/节假日。
  支持 2004年 至 2024年，包括 2020年 的春节延长。



  ```
  pip install chinesecalendar
  ```



  ```
  pip install -U chinesecalendar
  ```

  由于次年的节假日安排，取决于国务院发布的日程。
  所以本项目一般会在国务院更新以后，发布新的版本。
  按照以往的经验，一般是每年的 11月 前后发布新版本。



  ``` python
  import datetime


  from chinese_calendar import is_holiday, is_workday
  april_last = datetime.date(2018, 4, 30)
  assert is_workday(april_last) is False
  assert is_holiday(april_last) is True


  import chinese_calendar as calendar  # 也可以这样 import
  on_holiday, holiday_name = calendar.get_holiday_detail(april_last)
  assert on_holiday is True
  assert holiday_name == calendar.Holiday.labour_day.value


  import chinese_calendar
  assert chinese_calendar.is_in_lieu(datetime.date(2006, 2, 1)) is False
  assert chinese_calendar.is_in_lieu(datetime.date(2006, 2, 2)) is True
  ```



  假如你没法使用Python，
  你也可以转译现成的[常量文件][constants.py]来获取最全的节假日安排表。



  1. Fork + Clone 项目到本地
  2. 修改[节假日定义][scripts/data.py]
  3. 执行[脚本][scripts/__init__.py]自动生成[常量文件][constants.py]
  4. 提交PR

  [constants.py]: https://github.com/LKI/chinese-calendar/blob/master/chinese_calendar/constants.py
  [scripts/data.py]: https://github.com/LKI/chinese-calendar/blob/master/chinese_calendar/scripts/data.py
  [scripts/__init__.py]: https://github.com/LKI/chinese-calendar/blob/master/chinese_calendar/scripts/__init__.py


pkgId: bb5f29a9533dc95e537dc4bae322d84967aec71fe82d77c53a780418e2cfa2d3
name: python-chinese-converter
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: convert simplified chinese text to traditional chinese
url: https://github.com/zachary822/chinese-converter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinese-converter-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Converts between Traditional and Simplified Chinese. Uses monogram and bigram frequencies to pick optimal
  words when a 1-to-1 conversion is not possible.

  Uses phrases in the dictionary to count monogram and bigram frequencies.



  ```bash
  pip install chinese-converter
  ```



  ```python
  import chinese_converter

  chinese_converter.to_traditional("simplified chinese text...")
  chinese_converter.to_simplified("traditional chinese text...")

  ```



  ```bash
  python -m unittest
  ```



  MIT



  *Not necessary for the normal usage of this library.*

  1. Dictionary Files: https://resources.publicense.moe.edu.tw/dict_reviseddict_download.html

      - Dictionary licensed under [CC BY-ND 3.0 TW](https://creativecommons.org/licenses/by-nd/3.0/tw/).
      - Mirror: https://chinese-converter-data.s3.amazonaws.com/dict_revised_2015_20180409.zip


pkgId: 1fe995ddf8876322f7b37f93cdb0dc8f50f0a3479dd975c153c78207b8080be0
name: python-chinese-nonwords
arch: src
version: 0.0.19
epoch: 0
release: 1
summary: package for generating Chinese disyllabic nonwords
url: https://github.com/zimine/Chinese-nonwords-generator
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinese-nonwords-0.0.19-1.src.rpm
checksum_type: sha256
description:
  This package is developed based on [`strokes`](https://pypi.org/project/strokes/) and [`pinyin`](https://pypi.org/project/pinyin/). Use this package to generate Chinese disyllabic nonwords.



  ```python
  from chinese_nonwords import ChineseNonwords
  ```

  The `ChineseNonwords` function takes in the following arguments, in the following order:
  - stroke_min, stroke_max (min: 1; max: 25):
      - the minimum and maximum number of stroke a character has
  - num_nei_min, num_nei_max (min: 8; max: 307):
      - the minimum and maximum number of phonological neighborhood a character has
  - logfreq_min, logfreq_max (min: 0; max: 6.31):
      - the minimum and maximum number of frequency (log) of a character
  - N:
      - the number of disyllabic words to be generated (default=10)
  - random_state:
      - random state for sampling (default=42)



  ```python
  from chinese_nonwords import ChineseNonwords
  cnw = ChineseNonwords.generate_nonwords(stroke_min=2,
                                          stroke_max=18,
                                          num_nei_min=20,
                                          num_nei_max=300,
                                          logfreq_min=4,
                                          logfreq_max=6,
                                          N=10,
                                          random_state=42)
  ```
  Once specified, the run the `generate_nonwords()` function to get a tabulated list of nonwords. The pinyin of these nonwords were cross-checked with the [SUBTLEX-CH][1] to make sure it does not appear in the given list of known disyllabic words. The frequency information is extracted from [SUBTLEX-CH][1], stroke count from the [`strokes`](https://pypi.org/project/strokes/) package, and the rest of the lexical properties from [`Mandarin-Neighborhood-Statistics`](https://github.com/karlneergaard/Mandarin-Neighborhood-Statistics).

  Note that the length of the output is not always the same as specified (N), as there are nonwords that are phonologically similar to real disyllabic words, which are excluded. To generate another list with the same arguments, change `random_state` to a different value.

  ```
  print(cnw)
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  |    | Char-1   | Char-2   |   Logfreq-1 |   Logfreq-2 |   Stroke-1 |   Stroke-2 |   HD-1 |   HD-2 |   NumNeighbor-1 |   NumNeighbor-2 |
  +====+==========+==========+=============+=============+============+============+========+========+=================+=================+
  |  0 | 求       | 查       |        4.36 |        4.49 |          7 |          9 |      9 |      6 |             219 |             219 |
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  |  1 | 名       | 空       |        4.64 |        4.19 |          6 |          8 |      7 |      1 |             219 |             277 |
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  |  2 | 妈       | 何       |        4.9  |        4.58 |          6 |          7 |      3 |     12 |             278 |             219 |
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  |  3 | 法       | 比       |        4.78 |        4.71 |          8 |          4 |      2 |      5 |             261 |             262 |
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  |  4 | 乐       | 到       |        4.42 |        5.46 |          5 |          8 |      9 |      8 |             304 |             305 |
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  |  5 | 表       | 但       |        4.5  |        5.09 |          8 |          7 |      4 |     10 |             260 |             305 |
  +----+----------+----------+-------------+-------------+------------+------------+--------+--------+-----------------+-----------------+
  ```


  Similarly, you can use the `generate_words()` function to generate a list of disyllabic words that meet the specification.
  ```python
  from chinese_nonwords import ChineseNonwords
  cw = ChineseNonwords.generate_words(stroke_min=2,
                                      stroke_max=18,
                                      num_nei_min=100,
                                      num_nei_max=300,
                                      logfreq_min=3,
                                      logfreq_max=6,
                                      N=10,
                                      random_state=42)
  ```

  The output is in the same format as the nonword list.

  ```
  print(cw)
  +----+--------+-----------+---------------------+----------+----------------+
  |    | word   |   logfreq |   homophone_density |   stroke |   num_neighbor |
  +====+========+===========+=====================+==========+================+
  |  0 | 思考   |      3.08 |                 8   |      7.5 |          268.5 |
  +----+--------+-----------+---------------------+----------+----------------+
  |  1 | 家里   |      3.66 |                11   |      8.5 |          270   |
  +----+--------+-----------+---------------------+----------+----------------+
  |  2 | 迷人   |      3.03 |                 6.5 |      5.5 |          219.5 |
  +----+--------+-----------+---------------------+----------+----------------+
  |  3 | 交给   |      3.25 |                 7.5 |      7.5 |          268   |
  +----+--------+-----------+---------------------+----------+----------------+
  |  4 | 工具   |      3.02 |                13.5 |      5.5 |          291.5 |
  +----+--------+-----------+---------------------+----------+----------------+
  |  5 | 多久   |      3.64 |                 5   |      4.5 |          240   |
  +----+--------+-----------+---------------------+----------+----------------+
  |  6 | 理解   |      3.71 |                 6.5 |     12   |          262   |
  +----+--------+-----------+---------------------+----------+----------------+
  |  7 | 情绪   |      3.16 |                 7   |     11   |          262.5 |
  +----+--------+-----------+---------------------+----------+----------------+
  |  8 | 天气   |      3.1  |                 7.5 |      4   |          291.5 |
  +----+--------+-----------+---------------------+----------+----------------+
  |  9 | 酒吧   |      3.47 |                 3.5 |      8.5 |          136.5 |
  +----+--------+-----------+---------------------+----------+----------------+
  ```


  [1] [SUBTLEX-CH](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0010729&ref=https://githubhelp.com): Cai, Q., & Brysbaert, M. (2010). SUBTLEX-CH: Chinese word and character frequencies based on film subtitles. PloS one, 5(6), e10729.


pkgId: 291fdd9e97fe01e20e8cf05d3f475ff1461afab35afbf56781ab6a510e96ef5a
name: python-chinese-whispers
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: An implementation of the Chinese Whispers clustering algorithm.
url: https://github.com/nlpub/chinese-whispers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinese-whispers-0.9.0-1.src.rpm
checksum_type: sha256
description:
  This is an implementation of the [Chinese Whispers](https://doi.org/10.3115/1654758.1654774) clustering algorithm in Python. Since this library is based on [NetworkX](https://networkx.github.io/), it is simple to use.

  [![Unit Tests][github_tests_badge]][github_tests_link] [![Read the Docs][rtfd_badge]][rtfd_link] [![PyPI Version][pypi_badge]][pypi_link] [![Conda Version][conda_badge]][conda_link]

  [github_tests_badge]: https://github.com/nlpub/chinese-whispers/actions/workflows/test.yml/badge.svg?branch=master
  [github_tests_link]: https://github.com/nlpub/chinese-whispers/actions/workflows/test.yml
  [rtfd_badge]: https://readthedocs.org/projects/chinese-whispers/badge/
  [rtfd_link]: https://chinese-whispers.readthedocs.io/
  [pypi_badge]: https://badge.fury.io/py/chinese-whispers.svg
  [pypi_link]: https://pypi.python.org/pypi/chinese-whispers
  [conda_badge]: https://anaconda.org/conda-forge/chinese-whispers/badges/version.svg
  [conda_link]: https://anaconda.org/conda-forge/chinese-whispers



  - [pip](https://pip.pypa.io/): `pip install chinese-whispers`
  - [Anaconda](https://docs.conda.io/en/latest/): `conda install conda-forge::chinese-whispers`



  Given a NetworkX graph `G`, this library can [cluster](https://en.wikipedia.org/wiki/Cluster_analysis) it using the following code:

  ```python
  from chinese_whispers import chinese_whispers
  chinese_whispers(G, weighting='top', iterations=20)
  ```

  As the result, each node of the input graph is provided with the `label` attribute that stores the cluster label.

  The library also offers a convenient command-line interface (CLI) for clustering graphs represented in the ABC tab-separated format (source`\t`target`\t`weight).

  ```shell

  python3 -c 'import networkx as nx; nx.write_weighted_edgelist(nx.karate_club_graph(), "karate_club.tsv", delimiter="\t")'


  chinese-whispers karate_club.tsv


  python3 -mchinese_whispers karate_club.tsv
  ```

  A more complete usage example is available in the [example notebook](https://github.com/nlpub/chinese-whispers/blob/master/example.ipynb) and at <https://nlpub.github.io/chinese-whispers/>.

  In case you require higher performance, please consider our Java implementation that also includes other graph clustering algorithms: <https://github.com/nlpub/watset-java>.



  * [Ustalov, D.](https://github.com/dustalov), [Panchenko, A.](https://github.com/alexanderpanchenko), [Biemann, C.](https://www.inf.uni-hamburg.de/en/inst/ab/lt/people/chris-biemann.html), [Ponzetto, S.P.](https://www.uni-mannheim.de/dws/people/professors/prof-dr-simone-paolo-ponzetto/): [Watset: Local-Global Graph Clustering with Applications in Sense and Frame Induction](https://doi.org/10.1162/COLI_a_00354). Computational Linguistics 45(3), 423&ndash;479 (2019)

  ```bibtex
  @article{Ustalov:19:cl,
    author    = {Ustalov, Dmitry and Panchenko, Alexander and Biemann, Chris and Ponzetto, Simone Paolo},
    title     = {{Watset: Local-Global Graph Clustering with Applications in Sense and Frame Induction}},
    journal   = {Computational Linguistics},
    year      = {2019},
    volume    = {45},
    number    = {3},
    pages     = {423--479},
    doi       = {10.1162/COLI_a_00354},
    publisher = {MIT Press},
    issn      = {0891-2017},
    language  = {english},
  }
  ```



  Copyright (c) 2018&ndash;2024 [Dmitry Ustalov](https://github.com/dustalov). See [LICENSE](LICENSE) for details.


pkgId: 5df6bece79b5fa0278cf183201a24d2c810edcdb81777db3f79f9b80a660c2be
name: python-chinesename
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: get a chinesename by random
url: https://github.com/mouday/chinesename
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinesename-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/mouday/chinesename.svg?branch=master)](https://travis-ci.org/mouday/chinesename)
  [![PyPI](https://img.shields.io/pypi/v/chinesename.svg)](https://pypi.org/project/chinesename/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/chinesename.svg)


  项目包含《百家姓》姓氏504个，常用于名字的汉字2812个
  名字汉字中包含大部分《楚辞》、《诗经》词汇

  pypi地址： https://pypi.python.org/pypi/chinesename



  ```
  pip install chinesename
  ```



  ```python
  from chinesename import ChineseName  # 导包

  cn = ChineseName()  # 实例化

  cn.getName()  # 获取一个姓名
  '广袁'

  cn.getNames(10)  # 获取多个姓名
  ['笪递', '慎彭徨', '席具', '锺谦', '任西', '公羊狱', '华桑', '利节', '燕角', '任彪']

  cn.getNameGenerator(10)  # 获取生成器
  <generator object ChineseName.getNameGenerator at 0x1045cfa40>

  cn.getLastName()  # 获取姓氏
  '舒'

  cn.getFirstName()  # 获取名字
  '崔'

  cn.getName(lastname="彭")  # 设置姓氏
  '彭圭'

  cn.getName(char_count=2)  # 设置名字长度
  '倪吏渚'

  cn.getName(sex="boy")  # 设置性别 （boy | girl）
  '骆留'

  ```



  2018年1月22日 增加姓名生成器函数，getNameGenerator()


  2018年3月19日 修复导入lastnames 和 firstname 文件失败的问题，将两文件内容直接写到chinesename中，并删除两文件


  2018年6月20日 修复资源文件导入问题，增加性别参数，区分男孩姓名和女孩姓名
  感谢 JoffreyN 提出的建议 [古语云：男楚辞，女诗经。名可以从诗经、楚辞里面取](https://github.com/mouday/chinesename/issues/2)
  在原有基础上进行了扩展
  遗留问题：取词不准确，需要进一步优化


  2018年7月23日 修复文件open时引发的编码问题，增加参数：encoding="utf-8"

  2018年11月23日 修复pyhton2下安装报错'IOError: [Errno 2] No such file or directory: "README.md"'的问题


pkgId: 3d0a722b6afb4c128c4f181ca0d3cc0b712c207d8a877ff203e269ea1d842dee
name: python-ching
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: A simple money management library
url: https://pypi.org/project/ching/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ching-1.1.6-1.src.rpm
checksum_type: sha256
description:
  money money money!

  ching is a money tracking library for python!

  this is the library for you!
  it has built in money tracking functions and more!
  it also has security and blocks you from ecxeeding your moneylimit (made in the: moneylimit(NumberValue) function.)

  install latest version: `pip install ching` (recommended)
  install certain version `pip install ching==(version)` (not recommended)

  ```
  ching.limitmoney(NumberValue) # limit the amount of money able to be held in the tracking file.
  ching.getdate() # logs the date so it knows when to add allowances and income days
  ching.finddate() # find the date from the date logs, useful for allowance and income day tracking
  ching.addmoney(NumberValue) # add an amount of money to the tracking file.
  ching.minusmoney(NumberValue) # minus an amount of money from the tracking file.
  ching.printmoney() # print the amount of money in your tracking file
  ```
  all examples [here](https://github.com/webbrowser11/ching/blob/main/__test__/Main.py)


pkgId: 6529d37aa470c6862673a134b00bc466501fd8f14d7eeb33f5caf73e38064b6e
name: python-chinus-decorators
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: This is a chinus Python package.
url: https://github.com/juyoung9653/decorators
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinus-decorators-1.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a sample Python package created by Chinu9653.


  - Feature 1
  - Feature 2


  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install `chinus-decorators`.

  ```bash
  pip install chinus-decorators


pkgId: b8ace0e9fbbd5cedbf3d5136f1e807d78333ee46105cbca963cf6ae9c114d257
name: python-chinus-emotions
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: This is a chinus Python package.
url: https://github.com/juyoung9653/emotions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinus-emotions-1.0.2-1.src.rpm
checksum_type: sha256
description:
  This is a sample Python package created by Chinu9653.


  - Feature 1
  - Feature 2


  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install `chinus-emotions`.

  ```bash
  pip install chinus-emotions


pkgId: 341e4c43eb3784631da8bb7de0dc721172aefa35e409b6651a47d8355cf8d40c
name: python-chinus-tools
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: This is a chinus Python package.
url: https://github.com/juyoung9653/chinus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinus-tools-1.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a sample Python package created by Chinu9653.


  - Feature 1
  - Feature 2


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

  ```bash
  pip install chinus


pkgId: a7c9cee4f852d2f0b0391c63c504b26986fce6380055edae8d8041a94d183abb
name: python-chinus-tools
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: This is a chinus Python package.
url: https://github.com/juyoung9653/chinus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinus-tools-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This is a sample Python package created by Chinu9653.


  - Feature 1
  - Feature 2


  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install `chinus-tools`.

  ```bash
  pip install chinus-tools


pkgId: 94835d039cd72d631423326c0873c54d2717b665585b1b8023554a20164dd38a
name: python-chinus-uploads
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: This is a chinus Python package.
url: https://github.com/juyoung9653/uploads
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chinus-uploads-1.0.0-1.src.rpm
checksum_type: sha256
description:
  This is a sample Python package created by Chinu9653.


  - Feature 1
  - Feature 2


  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install `chinus-uploads`.

  ```bash
  pip install chinus-uploads


pkgId: b2f2e4d37636daeda7680633d3e766e780fb6fa37b38368abe5a1c9220acdd43
name: python-chipgr8
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Chip 8 Emulation for AI
url: https://awiggs.github.io/chip-gr8/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipgr8-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![logo](/docsource/static/img/readme-logo.png)](https://awiggs.github.io/chip-gr8/)



  Chip-Gr8 is a sandbox for creating AI Agents for retro video games like Pong, Breakout, and Space Invaders. Chip-Gr8 lets you interactively program AI agents, easily record their behaviour, collect data, pause and play their actions, and even play against them! If you have never programmed an AI before, Chip-Gr8 is a great place to start!


  Chip-Gr8 is a Python package. Use pip to install it!

  ```
  pip install chipgr8
  ```


  If you want to play a game using Chip-Gr8, all you have to do is start it on the command line! For example, to play breakout you would run

  ```
  python -m chipgr8 -r breakout
  ```

  You will be greated by the Chip-Gr8 display and can start playing!

  Creating an AI Agent is just as straightforward, just dropping the following code into your favorite text editor and you are ready to go!

  ```python
  import chipgr8
  from chipgr8.games import Breakout

  vm = chipgr8.init(display=True, ROM=Breakout.ROM)
  while not vm.done():
      vm.act(Breakout.actions.left)
  ```

  To find out more about Chip-Gr8, its API, included games, and more examples, download the [Reference Manual](https://awiggs.github.io/chip-gr8/static/Chip-Gr8-Reference-Manual.pdf), or head over to the [docs](https://awiggs.github.io/chip-gr8/docs)!



  Feel free to contact us with questions, bug reports, or feature requests at chipgr8.contact@gmail.com.


pkgId: ab3a908f313cf136fe3ae36663593b4f6e95fa525a9e7ae17c7f2249426d0b19
name: python-chippapi
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: This is a simple python wrapper for [Chipp](https://chipp.ai/).
url: https://github.com/skilledkitten/chippapi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chippapi-1.0.3-1.src.rpm
checksum_type: sha256
description:
  -> This is a simple python wrapper for [Chipp](https://chipp.ai/).


  ```bash
  pip install -i https://test.pypi.org/simple/ chippapi==1.0.3
  ```


  ```python
  import chippapi

  chippapi.api_key = "YOUR_API_KEY"
  chippapi.id = "YOUR_ID"

  response = chippapi.chat(prompt="Hello, how are you?")
  print(response)
  ```


  -> This project is licensed under the MIT license - see the [LICENSE](https://opensource.org/license/mit) for details.


pkgId: 088c38b4010a6c4e7b88ee047a2458b1100a67bd3153ee2cc0c0675596877914
name: python-chipscopy
arch: src
version: 2024.1.1717799899
epoch: 0
release: 1
url: https://github.com/Xilinx/chipscopy
rpm_license: Apache-2.0 AND EPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipscopy-2024.1.1717799899-1.src.rpm
checksum_type: sha256
summary:
  Open-source project from Xilinx® that enables high-level control of Versal debug IP running in hardware


pkgId: 8de5a4b1b2d7bc24c436f5b00d778c8ec416031e32f779999a283b9a7d6b8804
name: python-chipscopy
arch: src
version: 2024.2.1732227392
epoch: 0
release: 1
url: https://github.com/Xilinx/chipscopy
rpm_license: Apache-2.0 AND EPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipscopy-2024.2.1732227392-1.src.rpm
checksum_type: sha256
summary:
  Open-source project from Xilinx® that enables high-level control of Versal debug IP running in hardware

description:
  [![](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  ![](https://raw.githubusercontent.com/Xilinx/chipscopy/master/docs/images/chipscopy_logo_head_right_transparent_background.png)

  ChipScoPy is an open-source project from AMD that enables high-level control of Versal debug IP running in hardware.
  Using a simple Python API, developers can control and communicate with ChipScope® debug IP such as the Integrated Logic
  Analyzer (ILA), Virtual IO (VIO), device memory access, and more.

  ChipScoPy communicates with Versal devices. It does not work with older devices such as Ultrascale+ and 7-Series devices.

  **We recommend using Python 3.8, 3.9, 3.10, or 3.11 with ChipScoPy.**


  ![](https://raw.githubusercontent.com/Xilinx/chipscopy/master/docs/images/chipscopy_overview.png)



  [ChipScoPy Overview](https://xilinx.github.io/chipscopy/2024.2/overview.html)

  [System Requirements](https://xilinx.github.io/chipscopy/2024.2/system_requirements.html)

  [ChipScoPy Installation](https://xilinx.github.io/chipscopy/2024.2/chipscopy_installation.html)

  [ChipScoPy Examples](https://github.com/Xilinx/chipscopy/tree/master/chipscopy/examples)

  [FAQ](https://github.com/Xilinx/chipscopy/blob/master/FAQ.md)

  [API Documentation](https://xilinx.github.io/chipscopy/)




  During ChipScoPy installation, the following packages (and any dependencies) are installed from the Python Package Index (PyPI) using pip.

  | Package                                                                     |  License   |
  | :----------------------------------------------                             |  :------:  |
  | [Requests](https://pypi.org/project/requests/)                              | Apache-2.0 |
  | [more-itertools](https://pypi.org/project/more-itertools/)                  |    MIT     |
  | [typing_extensions](https://pypi.org/project/typing-extensions/)            |    PSF     |
  | [loguru](https://pypi.org/project/loguru/)                                  |    MIT     |
  | [importlib_metadata](https://pypi.org/project/importlib-metadata/)          | Apache-2.0 |
  | [rich](https://pypi.org/project/rich/)                                      |    MIT     |
  | [Click](https://pypi.org/project/click/)                                    |    BSD     |
  | [antlr4-python3-runtime](https://pypi.org/project/antlr4-python3-runtime/)  |    BSD     |
  | [kaleido](https://pypi.org/project/kaleido/)                                |    MIT     |
  | [plotly](https://pypi.org/project/plotly/)                                  |    MIT     |
  | [notebook](https://pypi.org/project/notebook/)                              |    BSD     |
  | [ipywidgets](https://pypi.org/project/ipywidgets/)                          |    BSD     |
  | [pandas](https://pypi.org/project/pandas/)                                  |    BSD     |
  | [matplotlib](https://pypi.org/project/matplotlib/)                          |    PSF     |
  | [PyQt5](https://pypi.org/project/PyQt5/)                                    |    GPL     |
  | [ipympl](https://pypi.org/project/ipympl/)                                  |    BSD     |




  Copyright (C) 2021-2022, Xilinx, Inc.

  Copyright (C) 2022-2024, Advanced Micro Devices, Inc.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 370f8ecabfa0b50f8087f16abf3cc5bc1aa86c12119bfcfde29660b9fbd6298b
name: python-chipscopy
arch: src
version: 2024.2.1733027508
epoch: 0
release: 1
url: https://github.com/Xilinx/chipscopy
rpm_license: Apache-2.0 AND EPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipscopy-2024.2.1733027508-1.src.rpm
checksum_type: sha256
summary:
  Open-source project from Xilinx® that enables high-level control of Versal debug IP running in hardware

description:
  [![](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  ![](https://raw.githubusercontent.com/Xilinx/chipscopy/master/docs/images/chipscopy_logo_head_right_transparent_background.png)

  ChipScoPy is an open-source project from AMD that enables high-level control of Versal debug IP running in hardware.
  Using a simple Python API, developers can control and communicate with ChipScope® debug IP such as the Integrated Logic
  Analyzer (ILA), Virtual IO (VIO), device memory access, and more.

  ChipScoPy supports Versal devices and has limited IBERT GTY support for Ultrascale+ devices.
  It does not work with older devices such as 7-Series devices.

  **We recommend using Python 3.8, 3.9, 3.10, 3.11, or 3.12 with ChipScoPy.**


  ![](https://raw.githubusercontent.com/Xilinx/chipscopy/master/docs/images/chipscopy_overview.png)



  [ChipScoPy Overview](https://xilinx.github.io/chipscopy/2024.2/overview.html)

  [System Requirements](https://xilinx.github.io/chipscopy/2024.2/system_requirements.html)

  [ChipScoPy Installation](https://xilinx.github.io/chipscopy/2024.2/chipscopy_installation.html)

  [ChipScoPy Examples](https://github.com/Xilinx/chipscopy/tree/master/chipscopy/examples)

  [FAQ](https://github.com/Xilinx/chipscopy/blob/master/FAQ.md)

  [API Documentation](https://xilinx.github.io/chipscopy/)




  During ChipScoPy installation, the following packages (and any dependencies) are installed from the Python Package Index (PyPI) using pip.

  | Package                                                                     |  License   |
  | :----------------------------------------------                             |  :------:  |
  | [Requests](https://pypi.org/project/requests/)                              | Apache-2.0 |
  | [more-itertools](https://pypi.org/project/more-itertools/)                  |    MIT     |
  | [typing_extensions](https://pypi.org/project/typing-extensions/)            |    PSF     |
  | [loguru](https://pypi.org/project/loguru/)                                  |    MIT     |
  | [importlib_metadata](https://pypi.org/project/importlib-metadata/)          | Apache-2.0 |
  | [rich](https://pypi.org/project/rich/)                                      |    MIT     |
  | [Click](https://pypi.org/project/click/)                                    |    BSD     |
  | [antlr4-python3-runtime](https://pypi.org/project/antlr4-python3-runtime/)  |    BSD     |
  | [kaleido](https://pypi.org/project/kaleido/)                                |    MIT     |
  | [plotly](https://pypi.org/project/plotly/)                                  |    MIT     |
  | [notebook](https://pypi.org/project/notebook/)                              |    BSD     |
  | [ipywidgets](https://pypi.org/project/ipywidgets/)                          |    BSD     |
  | [pandas](https://pypi.org/project/pandas/)                                  |    BSD     |
  | [matplotlib](https://pypi.org/project/matplotlib/)                          |    PSF     |
  | [PyQt5](https://pypi.org/project/PyQt5/)                                    |    GPL     |
  | [ipympl](https://pypi.org/project/ipympl/)                                  |    BSD     |




  Copyright (C) 2021-2022, Xilinx, Inc.

  Copyright (C) 2022-2024, Advanced Micro Devices, Inc.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: e04b1b7f48dfa0e04545b94e584f9a6db31376693292bda255d2c96b75c99a81
name: python-chipseqpeaks
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Easy management of ChIP-seq peak calling
url: https://gitlab.com/aaylward/chipseqpeaks
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipseqpeaks-1.1.5-1.src.rpm
checksum_type: sha256
description:
  A wrapper for MACS2 that abstracts out some things and makes it easier to use.
  Thanks due to Joshua Chiou for inspiration and contributions.

  > **Warning:** Before using chipseqpeaks, please make sure that one of the
  > environment variables TMPDIR, TEMP, or TMP is set to an appropriate path.
  > This is the only way to ensure MACS2 writes temporary files to the correct
  > location, and failing to do so may cause errors on some systems. (ง •̀_•́)ง



  ```sh
  pip install chipseqpeaks
  ```

  or

  ```sh
  pip install --user chipseqpeaks
  ```


  ```python
  from chipseqpeaks import ChIPSeqPeaks
  with ChIPSeqPeaks(<bytes object or path to BAM file>) as cp:
      cp.cleans_up = False
      cp.remove_blacklisted_peaks(<path/to/blacklist.bed>)
      cp.write(<output prefix>)
  ```



  For help text, see:
  ```sh
  chipseqpeaks-call -h
  ```
  For ChIP-seq:
  ```sh
  chipseqpeaks-call --control input.bam chip.bam
  ```

  For ATAC-seq:
  ```sh
  chipseqpeaks-call --atac-seq atac.bam
  ```


pkgId: f7bee17e6e8e36999f3b63e6b255241884af39ae0636bceb12d2b301fe77cacf
name: python-chipstream
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: GUI and CLI for DC data postprocessing
url: https://pypi.org/project/chipstream/
rpm_license: GPL version 3.0 or later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipstream-0.6.3-1.src.rpm
checksum_type: sha256
description:
  |PyPI Version| |Build Status| |Coverage Status| |Docs Status|
  **ChipStream** is a graphical user interface for postprocessing
  deformability cytometry (DC) data. This includes background computation,
  event segmentation, and feature extraction.


pkgId: a9e2136915f3b6dcac11ad16a3b1b0694c32bd2cb8b9c52edc314f632755ee04
name: python-chipwhisperer
arch: src
version: 5.7.0
epoch: 0
release: 1
summary: ChipWhisperer Side-Channel Analysis Tool
url: https://www.chipwhisperer.com
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chipwhisperer-5.7.0-1.src.rpm
checksum_type: sha256
description:
  First time using ChipWhisperer? Check out these links:
  * [Getting started](https://chipwhisperer.readthedocs.io/en/latest/getting-started.html)
  * [Installing ChipWhisperer](https://chipwhisperer.readthedocs.io/en/latest/index.html#install) if you're trying to set up this software package
  * [Hardware Docs](https://rtfm.newae.com) for hardware information. Also has helpful comparison between different NewAE products.

  ChipWhisperer 5.5 has brought some exciting new features that make it easier to use and allow you to do some cool new things:
  1. The ChipWhisperer Windows installer now includes everything you need to use ChipWhisperer, including
  Python/Juptyer, Git, Make, and compilers! For more information, check out our [Windows installer page](https://chipwhisperer.readthedocs.io/en/latest/windows-install.html) on ReadTheDocs.
  1. ChipWhisperer capture devices (CWLite, Nano, Pro, etc.) have gotten a new firmware update that gives them a
  USB-CDC serial port for talking over USART. This means you can use your favourite serial program, such as PuTTy,
  to talk to and listen to the target's USART communication. For more info, see our [rtfm serial port page](https://rtfm.newae.com/Serial%20Ports/).
  1. We've recently added two ECC power analysis attack notebooks. One attacks a hardware ECC implementation running on the CW305
  and the other attacks a software ECC implementation running on a microcontroller. Both can be found in `jupyter/demos`.
  1. There's a new segmented capture mode that allows you to fill the ChipWhisperer capture buffer with multiple power traces
  before transferring data to the PC. This greatly reduces the overhead on trace transfer, allowing capture speeds
  of 1000+ captures/second for FPGA AES implementations. See our [API documentation](https://chipwhisperer.readthedocs.io/en/latest/scope-api.html#chipwhisperer.capture.scopes._OpenADCInterface.TriggerSettings.fifo_fill_mode) to see how to use it.
  Also, if you haven't checked it out yet, ChipWhisperer 5.4 included TraceWhisperer, which allows you to use Arm trace to
  timestamp microcontroller operations/functions in your powertrace. It requires a CW305 or PhyWhisperer. For more information, see
  https://github.com/newaetech/DesignStartTrace.

  Note all development occurs on the [develop](https://github.com/newaetech/chipwhisperer/tree/develop) branch. If you are looking for bleeding edge it's NOT on master - we push each release (and possibly any critical changes) to master. This means that "master" always gives you the latest known-working branch, but there may be new features on the "develop" branch.

  Stuck? If you need a hand, there are a few places you can ask for help:
  * The [NewAE Forum](https://forum.newae.com/) is full of helpful people that can point you in the right direction


pkgId: e3144f88bd0774bda56824b2877b4f0195aa95a31b6910296622830fc0c575fb
name: python-chiralfinder
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: The chiralfinder package.
url: https://github.com/Meteor-han/chiralfinder/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chiralfinder-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Data and codes for the paper "ChiralFinder: an Open-Source Tool for Precise Stereogenic Element Detection and Stereoisomer Discrimination", in submission.



  Install Anaconda, create and enter your own environment like

      conda create -n env_test python=3.10
  Enter the conda environment and install the ChiralFinder package through pip like

  ```
  conda activate env_test
  pip install chiralfinder
  ```

  Run `test.py` to get example results.

  ```
  python test.py
  ```

  ```python
  from chiralfinder import ChiralFinder

  if __name__ == '__main__':
      smi_list = ["C[C@H]1CC(=O)[C@]2(CCCC2=O)C1", "CC1=CC=C(SC2=C(C)N(C3=CC=CC=C3C(C)(C)C)C(C)=C2)C=C1"]

      chiral_finder = ChiralFinder(smi_list, "SMILES")
      res_ = chiral_finder.get_axial()
      print(res_[0]["chiral axes"], res_[1]["chiral axes"])
      chiral_finder.draw_res_axial("./img")

      smi_list_center = ["BrC/C(=C\[C@@H]1CCCO1)C1CCCCC1"]
      chiral_finder = ChiralFinder(smi_list_center, "SMILES")
      res_ = chiral_finder.get_central()
      print(res_)
  ```

  You will get the images of two molecules with predicted chiral axes in the folder `./img` by default. Predicted chiral axes:

  ```
  [(5,)] [(9, 10)]
  ```

  <img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/0.png" alt="0" width="30%" height="auto" /><img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/1.png" alt="1"  width="30%" height="auto" />

  You will get the prediction of one molecule for central chirality.

  ```
  [{
  'center id': [4],
  'quadrupole matrix':
         [[array([[-0.29989323, -1.08474687,  0.09943544],
         [-2.0754821 ,  0.47857598,  1.02051223],
         [-0.0064714 , -0.03258116,  2.29906673]])]],
  'determinant': [[-5.501797575969392]],
  'sign': [[-1.0]]
  }]
  ```






  The RotA dataset in excel with labeled chiral axes and some calculated molecular properties is stored in the folder `./data`.



  ```
  To be filled
  ```


pkgId: a705f22690b297ab044d60cbd6f7eab7ca0b83a44d7e409f08d3c1241ad2d1c1
name: python-chiralfinder
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: The chiralfinder package.
url: https://github.com/Meteor-han/chiralfinder/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chiralfinder-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Data and codes for the paper "ChiralFinder: an Open-Source Tool for Precise Stereogenic Element Detection and Stereoisomer Discrimination", in submission.



  Install Anaconda, create and enter your own environment like

      conda create -n env_test python=3.10
  Enter the conda environment and install the ChiralFinder package through pip like

  ```
  conda activate env_test
  pip install chiralfinder
  ```

  Run `test.py` to get example results.

  ```
  python test.py
  ```

  ```python
  from chiralfinder import ChiralFinder

  if __name__ == '__main__':
      smi_list = ["C[C@H]1CC(=O)[C@]2(CCCC2=O)C1", "CC1=CC=C(SC2=C(C)N(C3=CC=CC=C3C(C)(C)C)C(C)=C2)C=C1"]

      chiral_finder = ChiralFinder(smi_list, "SMILES")
      res_ = chiral_finder.get_axial(n_cpus=8)
      print(res_[0]["chiral axes"], res_[1]["chiral axes"])
      chiral_finder.draw_res_axial("./img")

      smi_list_center = ["BrC/C(=C\[C@@H]1CCCO1)C1CCCCC1"]
      chiral_finder = ChiralFinder(smi_list_center, "SMILES")
      res_ = chiral_finder.get_central()
      print(res_)
  ```

  You will get the images of two molecules with predicted chiral axes in the folder `./img` by default. Predicted chiral axes:

  ```
  [(5,)] [(9, 10)]
  ```

  <img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/0.png" alt="0" width="30%" height="auto" /><img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/1.png" alt="1"  width="30%" height="auto" />

  You will get the prediction of one molecule for central chirality.

  ```
  [{
  'center id': [4],
  'quadrupole matrix':
         [[array([[-0.29989323, -1.08474687,  0.09943544],
         [-2.0754821 ,  0.47857598,  1.02051223],
         [-0.0064714 , -0.03258116,  2.29906673]])]],
  'determinant': [[-5.501797575969392]],
  'sign': [[-1.0]]
  }]
  ```






  The RotA dataset in excel with labeled chiral axes and some calculated molecular properties is stored in the folder `./data`.



  ```
  To be filled
  ```


pkgId: c428d8b8a6b19b40d54dcb4d3ca46eff2f67c3e86470bac8f6173941c7c276b2
name: python-chirp-64
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Cross-correlation based digital mode reciever/simulator for amateur radios
url: https://github.com/valibali/chirp-64
rpm_license: BIOS
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chirp-64-0.0.4-1.src.rpm
checksum_type: sha256
description:
  A Python-based simulator for chirp modulation communication systems. This project implements a complete modem system using chirp signals for binary data transmission, including frame synchronization, payload handling, and error detection.



  - Configurable chirp-based modulation
  - Frame synchronization using preamble and Start Frame Delimiter (SFD)
  - CRC32 error detection
  - Configurable noise simulation
  - Detailed signal visualization and analysis tools
  - Support for WAV file input/output
  - Multiple verbosity levels for debugging



  ```
  chirp-64/
  ├── pyproject.toml    # Poetry configuration
  ├── src/
  |   ├── chirp_64/      # Main package directory
  |   │   ├── __init__.py
  |   │   ├── __main__.py   # Entry point
  |   │   ├── config.py     # Configuration parameters and validation
  |   │   ├── signal_processor.py # Signal processing utilities
  |   │   ├── modem.py      # Transmitter, Receiver, and Channel classes
  |   │   └── plotter.py    # Visualization tools
  ├── tests/            # Test directory
  │   └── __init__.py
  └── README.md         # This file
  ```



  - Python 3.8+
  - Poetry for dependency management



  1. Install Poetry if you haven't already:
  ```bash
  curl -sSL https://install.python-poetry.org | python3 -
  ```

  2. Clone the repository:
  ```bash
  git clone https://github.com/yourusername/chirp-64.git
  cd chirp-64
  ```

  3. Install dependencies using Poetry:
  ```bash
  poetry install
  ```





  With Poetry, run the module using:

  Generate and transmit a new signal:
  ```bash
  poetry run chirp-64 -o output.wav
  ```

  Process an existing WAV file:
  ```bash
  poetry run chirp-64 -i input.wav
  ```



  Alternatively, you can run using Python module syntax:
  ```bash
  poetry run python -m chirp_64 -o output.wav
  ```



  The program supports multiple verbosity levels:
  - Default: Only warnings and errors
  - `-v`: Basic info (SNR, BER, status messages)
  - `-vv`: Info + signal plots
  - `-vvv`: Debug info + all plots including correlations



  All major parameters can be configured via command-line arguments:

  ```bash
  poetry run chirp-64 -o output.wav \
      --fs 48000 \            # Sampling frequency (Hz)
      --baud-rate 200 \       # Symbols per second
      --f-start 2000 \        # Start frequency for chirps (Hz)
      --f-end 2400 \          # End frequency for chirps (Hz)
      --amplitude 0.8 \       # Chirp amplitude
      --noise-power 0.5 \     # Noise power
      --preamble "11001100" \ # Preamble bit sequence
      --sfd "11111111" \      # Start Frame Delimiter sequence
      --payload-length 128 \  # Number of payload bits
      --max-bits 1000        # Maximum bits to annotate in plots
  ```



  1. Generate signal with default parameters:
  ```bash
  poetry run chirp-64 -o output.wav
  ```

  2. Generate and visualize signal:
  ```bash
  poetry run chirp-64 -vv -o output.wav
  ```

  3. Process input file with custom parameters:
  ```bash
  poetry run chirp-64 -v -i input.wav --baud-rate 200 --f-start 2000 --f-end 2400
  ```

  4. Full debug mode with all plots:
  ```bash
  poetry run chirp-64 -vvv -o output.wav
  ```





  1. Clone the repository:
  ```bash
  git clone https://github.com/yourusername/chirp-64.git
  cd chirp-64
  ```

  2. Install development dependencies:
  ```bash
  poetry install --with dev
  ```

  3. Activate the virtual environment:
  ```bash
  poetry shell
  ```



  ```bash
  poetry run pytest
  ```



  Format code using black:
  ```bash
  poetry run black chirp_64
  ```



  The transmitted frame consists of:
  1. Preamble (8 bits): For frame detection
  2. Start Frame Delimiter (8 bits): For frame synchronization
  3. Payload Size Field (16 bits): Indicates payload length
  4. Payload (variable length): User data
  5. CRC32 (32 bits): Error detection



  - WAV files containing the modulated signal
  - Plot visualizations (when using -vv or -vvv):
    - Transmitted signal with bit annotations
    - Received signal with frame structure markers
    - Correlation plots for frame detection



  The program provides different levels of logging:

  - Transmission data (payload, CRC)
  - Reception data (received payload, CRC)
  - Signal-to-Noise Ratio (SNR)
  - Bit Error Rate (BER)
  - Frame detection status
  - Various debug information at higher verbosity levels





  ```bash
  poetry run chirp-64 -o output.wav \
      --preamble "10101010" \
      --sfd "11110000" \
      --payload-length 128
  ```



  ```bash
  poetry run chirp-64 -o output.wav --noise-power 2.0
  ```



  ```bash
  poetry run chirp-64 -o output.wav --baud-rate 200 --fs 48000
  ```



  1. Fork the project
  2. Create your feature branch (`git checkout -b feature/amazing-feature`)
  3. Install development dependencies (`poetry install --with dev`)
  4. Make your changes
  5. Run tests (`poetry run pytest`)
  6. Format code (`poetry run black chirp_64`)
  7. Commit your changes (`git commit -m 'Add amazing feature'`)
  8. Push to the branch (`git push origin feature/amazing-feature`)
  9. Open a Pull Request



  MIT License


pkgId: 1eea91ebcbb6f9213dad77729db208b48b9f70acfa08041737fdd2f9709418d4
name: python-chirpstack-api
arch: src
version: 4.10.1
epoch: 0
release: 1
summary: Chirpstack Python API
url: https://github.com/brocaar/chirpstack-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chirpstack-api-4.10.1-1.src.rpm
checksum_type: sha256
description:
  ChirpStack gRPC API message and service wrappers for Python.



  ```sh
  pip install chirpstack-api
  ```



  All messages, services, constants, etc. are auto-generated from the ChirpStack
  protobuf definitions. The result is that this package structure matches that
  of the protobuf definitions.

  The protobuf definitions can be found here:
  [https://github.com/chirpstack/chirpstack/tree/master/api/proto](https://github.com/chirpstack/chirpstack/tree/master/api/proto)



  * [`chirpstack-api` Python package page](https://pypi.org/project/chirpstack-api/)
  * [ChirpStack documentation](https://www.chirpstack.io/)
  * [Code examples](https://www.chirpstack.io/docs/chirpstack/api/python-examples.html)


pkgId: 0b2e04efa691f39ed50af1d9db5b4ce9e532c2af0e72e8126905cc5c4c46c0ff
name: python-chirptext
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A minimalist collection of text processing tools for Python 3
url: https://github.com/letuananh/chirptext/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chirptext-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.


pkgId: b46f2f6baccd2b8d044a5e9125d2102f454ea83c887ac9c313c0949f2c8e828c
name: python-chisel
arch: src
version: 1.3.6
epoch: 0
release: 1
summary: Lightweight WSGI application framework, schema-validated JSON APIs, and API documentation
url: https://github.com/craigahobbs/chisel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chisel-1.3.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Status](https://img.shields.io/pypi/status/chisel)](https://pypi.org/project/chisel/)
  [![PyPI](https://img.shields.io/pypi/v/chisel)](https://pypi.org/project/chisel/)
  [![GitHub](https://img.shields.io/github/license/craigahobbs/chisel)](https://github.com/craigahobbs/chisel/blob/main/LICENSE)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chisel)](https://pypi.org/project/chisel/)

  Chisel is a light-weight Python WSGI application framework built for creating well-documented,
  schema-validated JSON web APIs.




  - [API Documentation](https://craigahobbs.github.io/chisel/)
  - [Source code](https://github.com/craigahobbs/chisel)




  Chisel provides the [action](https://craigahobbs.github.io/chisel/action.html#chisel.action)
  decorator for easily implementing schema-validated JSON APIs.

  ~~~ python
  @chisel.action(spec='''

  action sum_numbers
      urls
         GET

      query
          
          float[len > 0] numbers

      output
          
          float sum
  ''')
  def sum_numbers(ctx, req):
      return {'sum': sum(req['numbers'])}

  application = chisel.Application()
  application.add_request(sum_numbers)
  application.request('GET', '/sum_numbers', query_string='numbers.0=1&numbers.1=2&numbers.2=4')

  ('200 OK', [('Content-Type', 'application/json')], b'{"sum":7.0}')
  ~~~

  Each action defines an ``action`` definition using
  [Schema Markdown](https://craigahobbs.github.io/schema-markdown-js/language/).
  The action callback is passed two arguments, a request
  [Context](https://craigahobbs.github.io/chisel/app.html#chisel.Context)
  and the schema-validated request input dictionary. The input request dictionary is created by
  combining the request's URL path parameters, query string parameters, and input JSON content
  parameters.

  If there is a schema validation error the appropriate error code is automatically returned.

  ~~~ python
  status, _, content_bytes = application.request('GET', '/sum_numbers')

  '400 Bad Request'
  b'{"error":"InvalidInput","message":"Required member \'numbers\' missing (query string)"}'
  ~~~




  You can add API documentation to your application by adding the Chisel documentation application
  requests from
  [create_doc_requests](https://craigahobbs.github.io/chisel/request.html#chisel.create_doc_requests).

  ~~~ python
  application = chisel.Application()
  application.add_requests(chisel.create_doc_requests())
  ~~~

  By default the documentation application is hosted at "/doc/". An example of of Chisel's documentation output is
  available [here](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request').




  This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).
  It was started using [python-template](https://github.com/craigahobbs/python-template#readme) as follows:

  ~~~ sh
  template-specialize python-template/template/ chisel/ -k package chisel -k name 'Craig A. Hobbs' -k email 'craigahobbs@gmail.com' -k github 'craigahobbs' -k nomain 1
  ~~~


pkgId: 5d2f301f2f41a0fe808a6c833b8ed76b09fe9a9bd1e3e114512b6c2aeff1a060
name: python-chispa
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Pyspark test helper library
url: https://github.com/MrPowers/chispa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chispa-0.10.1-1.src.rpm
checksum_type: sha256
description:
  ![![image](https://github.com/MrPowers/chispa/workflows/build/badge.svg)](https://github.com/MrPowers/chispa/actions/workflows/ci.yml/badge.svg)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/chispa)
  [![PyPI version](https://badge.fury.io/py/chispa.svg)](https://badge.fury.io/py/chispa)

  chispa provides fast PySpark test helper methods that output descriptive error messages.

  This library makes it easy to write high quality PySpark code.

  Fun fact: "chispa" means Spark in Spanish ;)



  Install the latest version with `pip install chispa`.

  If you use Poetry, add this library as a development dependency with `poetry add chispa -G dev`.



  Suppose you have a function that removes the non-word characters in a string.

  ```python
  def remove_non_word_characters(col):
      return F.regexp_replace(col, "[^\\w\\s]+", "")
  ```

  Create a `SparkSession` so you can create DataFrames.

  ```python
  from pyspark.sql import SparkSession

  spark = (SparkSession.builder
    .master("local")
    .appName("chispa")
    .getOrCreate())
  ```

  Create a DataFrame with a column that contains strings with non-word characters, run the `remove_non_word_characters` function, and check that all these characters are removed with the chispa `assert_column_equality` method.

  ```python
  import pytest

  from chispa.column_comparer import assert_column_equality
  import pyspark.sql.functions as F

  def test_remove_non_word_characters_short():
      data = [
          ("jo&&se", "jose"),
          ("**li**", "li"),
          ("#::luisa", "luisa"),
          (None, None)
      ]
      df = (spark.createDataFrame(data, ["name", "expected_name"])
          .withColumn("clean_name", remove_non_word_characters(F.col("name"))))
      assert_column_equality(df, "clean_name", "expected_name")
  ```

  Let's write another test that'll fail to see how the descriptive error message lets you easily debug the underlying issue.

  Here's the failing test:

  ```python
  def test_remove_non_word_characters_nice_error():
      data = [
          ("matt7", "matt"),
          ("bill&", "bill"),
          ("isabela*", "isabela"),
          (None, None)
      ]
      df = (spark.createDataFrame(data, ["name", "expected_name"])
          .withColumn("clean_name", remove_non_word_characters(F.col("name"))))
      assert_column_equality(df, "clean_name", "expected_name")
  ```

  Here's the nicely formatted error message:

  ![ColumnsNotEqualError](https://github.com/MrPowers/chispa/blob/main/images/columns_not_equal_error.png)

  You can see the `matt7` / `matt` row of data is what's causing the error (note it's highlighted in red).  The other rows are colored blue because they're equal.



  We can also test the `remove_non_word_characters` method by creating two DataFrames and verifying that they're equal.

  Creating two DataFrames is slower and requires more code, but comparing entire DataFrames is necessary for some tests.

  ```python
  from chispa.dataframe_comparer import *

  def test_remove_non_word_characters_long():
      source_data = [
          ("jo&&se",),
          ("**li**",),
          ("#::luisa",),
          (None,)
      ]
      source_df = spark.createDataFrame(source_data, ["name"])

      actual_df = source_df.withColumn(
          "clean_name",
          remove_non_word_characters(F.col("name"))
      )

      expected_data = [
          ("jo&&se", "jose"),
          ("**li**", "li"),
          ("#::luisa", "luisa"),
          (None, None)
      ]
      expected_df = spark.createDataFrame(expected_data, ["name", "clean_name"])

      assert_df_equality(actual_df, expected_df)
  ```

  Let's write another test that'll return an error, so you can see the descriptive error message.

  ```python
  def test_remove_non_word_characters_long_error():
      source_data = [
          ("matt7",),
          ("bill&",),
          ("isabela*",),
          (None,)
      ]
      source_df = spark.createDataFrame(source_data, ["name"])

      actual_df = source_df.withColumn(
          "clean_name",
          remove_non_word_characters(F.col("name"))
      )

      expected_data = [
          ("matt7", "matt"),
          ("bill&", "bill"),
          ("isabela*", "isabela"),
          (None, None)
      ]
      expected_df = spark.createDataFrame(expected_data, ["name", "clean_name"])

      assert_df_equality(actual_df, expected_df)
  ```

  Here's the nicely formatted error message:

  ![DataFramesNotEqualError](https://github.com/MrPowers/chispa/blob/main/images/dfs_not_equal_error.png)



  You can easily compare DataFrames, ignoring the order of the rows.  The content of the DataFrames is usually what matters, not the order of the rows.

  Here are the contents of `df1`:

  ```
  +--------+
  |some_num|
  +--------+
  |       1|
  |       2|
  |       3|
  +--------+
  ```

  Here are the contents of `df2`:

  ```
  +--------+
  |some_num|
  +--------+
  |       2|
  |       1|
  |       3|
  +--------+
  ```

  Here's how to confirm `df1` and `df2` are equal when the row order is ignored.

  ```python
  assert_df_equality(df1, df2, ignore_row_order=True)
  ```

  If you don't specify to `ignore_row_order` then the test will error out with this message:

  ![ignore_row_order_false](https://github.com/MrPowers/chispa/blob/main/images/ignore_row_order_false.png)

  The rows aren't ordered by default because sorting slows down the function.



  This section explains how to compare DataFrames, ignoring the order of the columns.

  Suppose you have the following `df1`:

  ```
  +----+----+
  |num1|num2|
  +----+----+
  |   1|   7|
  |   2|   8|
  |   3|   9|
  +----+----+
  ```

  Here are the contents of `df2`:

  ```
  +----+----+
  |num2|num1|
  +----+----+
  |   7|   1|
  |   8|   2|
  |   9|   3|
  +----+----+
  ```

  Here's how to compare the equality of `df1` and `df2`, ignoring the column order:

  ```python
  assert_df_equality(df1, df2, ignore_column_order=True)
  ```

  Here's the error message you'll see if you run `assert_df_equality(df1, df2)`, without ignoring the column order.

  ![ignore_column_order_false](https://github.com/MrPowers/chispa/blob/main/images/ignore_column_order_false.png)



  Each column in a schema has three properties: a name, data type, and nullable property.  The column can accept null values if `nullable` is set to true.

  You'll sometimes want to ignore the nullable property when making DataFrame comparisons.

  Suppose you have the following `df1`:

  ```
  +-----+---+
  | name|age|
  +-----+---+
  | juan|  7|
  |bruna|  8|
  +-----+---+
  ```

  And this `df2`:

  ```
  +-----+---+
  | name|age|
  +-----+---+
  | juan|  7|
  |bruna|  8|
  +-----+---+
  ```

  You might be surprised to find that in this example, `df1` and `df2` are not equal and will error out with this message:

  ![nullable_off_error](https://github.com/MrPowers/chispa/blob/main/images/nullable_off_error.png)

  Examine the code in this contrived example to better understand the error:

  ```python
  def ignore_nullable_property():
      s1 = StructType([
         StructField("name", StringType(), True),
         StructField("age", IntegerType(), True)])
      df1 = spark.createDataFrame([("juan", 7), ("bruna", 8)], s1)
      s2 = StructType([
         StructField("name", StringType(), True),
         StructField("age", IntegerType(), False)])
      df2 = spark.createDataFrame([("juan", 7), ("bruna", 8)], s2)
      assert_df_equality(df1, df2)
  ```

  You can ignore the nullable property when assessing equality by adding a flag:

  ```python
  assert_df_equality(df1, df2, ignore_nullable=True)
  ```

  Elements contained within an `ArrayType()` also have a nullable property, in addition to the nullable property of the column schema. These are also ignored when passing `ignore_nullable=True`.

  Again, examine the following code to understand the error that `ignore_nullable=True` bypasses:

  ```python
  def ignore_nullable_property_array():
      s1 = StructType([
          StructField("name", StringType(), True),
          StructField("coords", ArrayType(DoubleType(), True), True),])
      df1 = spark.createDataFrame([("juan", [1.42, 3.5]), ("bruna", [2.76, 3.2])], s1)
      s2 = StructType([
          StructField("name", StringType(), True),
          StructField("coords", ArrayType(DoubleType(), False), True),])
      df2 = spark.createDataFrame([("juan", [1.42, 3.5]), ("bruna", [2.76, 3.2])], s2)
      assert_df_equality(df1, df2)
  ```



  Python has NaN (not a number) values and two NaN values are not considered equal by default.  Create two NaN values, compare them, and confirm they're not considered equal by default.

  ```python
  nan1 = float('nan')
  nan2 = float('nan')
  nan1 == nan2 # False
  ```

  pandas considers NaN values to be equal by default, but this library requires you to set a flag to consider two NaN values to be equal.

  ```python
  assert_df_equality(df1, df2, allow_nan_equality=True)
  ```



  You can specify custom formats for the printed error messages as follows:

  ```python
  from chispa import FormattingConfig

  formats = FormattingConfig(
          mismatched_rows={"color": "light_yellow"},
          matched_rows={"color": "cyan", "style": "bold"},
          mismatched_cells={"color": "purple"},
          matched_cells={"color": "blue"},
      )

  assert_basic_rows_equality(df1.collect(), df2.collect(), formats=formats)
  ```

  or similarly:

  ```python
  from chispa import FormattingConfig, Color, Style

  formats = FormattingConfig(
          mismatched_rows={"color": Color.LIGHT_YELLOW},
          matched_rows={"color": Color.CYAN, "style": Style.BOLD},
          mismatched_cells={"color": Color.PURPLE},
          matched_cells={"color": Color.BLUE},
      )

  assert_basic_rows_equality(df1.collect(), df2.collect(), formats=formats)
  ```

  You can also define these formats in `conftest.py` and inject them via a fixture:

  ```python
  @pytest.fixture()
  def chispa_formats():
      return FormattingConfig(
          mismatched_rows={"color": "light_yellow"},
          matched_rows={"color": "cyan", "style": "bold"},
          mismatched_cells={"color": "purple"},
          matched_cells={"color": "blue"},
      )

  def test_shows_assert_basic_rows_equality(chispa_formats):
    ...
    assert_basic_rows_equality(df1.collect(), df2.collect(), formats=chispa_formats)
  ```

  ![custom_formats](https://github.com/MrPowers/chispa/blob/main/images/custom_formats.png)



  We can check if columns are approximately equal, which is especially useful for floating number comparisons.

  Here's a test that creates a DataFrame with two floating point columns and verifies that the columns are approximately equal.  In this example, values are considered approximately equal if the difference is less than 0.1.

  ```python
  def test_approx_col_equality_same():
      data = [
          (1.1, 1.1),
          (2.2, 2.15),
          (3.3, 3.37),
          (None, None)
      ]
      df = spark.createDataFrame(data, ["num1", "num2"])
      assert_approx_column_equality(df, "num1", "num2", 0.1)
  ```

  Here's an example of a test with columns that are not approximately equal.

  ```python
  def test_approx_col_equality_different():
      data = [
          (1.1, 1.1),
          (2.2, 2.15),
          (3.3, 5.0),
          (None, None)
      ]
      df = spark.createDataFrame(data, ["num1", "num2"])
      assert_approx_column_equality(df, "num1", "num2", 0.1)
  ```

  This failing test will output a readable error message so the issue is easy to debug.

  ![ColumnsNotEqualError](https://github.com/MrPowers/chispa/blob/main/images/columns_not_approx_equal.png)



  Let's create two DataFrames and confirm they're approximately equal.

  ```python
  def test_approx_df_equality_same():
      data1 = [
          (1.1, "a"),
          (2.2, "b"),
          (3.3, "c"),
          (None, None)
      ]
      df1 = spark.createDataFrame(data1, ["num", "letter"])

      data2 = [
          (1.05, "a"),
          (2.13, "b"),
          (3.3, "c"),
          (None, None)
      ]
      df2 = spark.createDataFrame(data2, ["num", "letter"])

      assert_approx_df_equality(df1, df2, 0.1)
  ```

  The `assert_approx_df_equality` method is smart and will only perform approximate equality operations for floating point numbers in DataFrames.  It'll perform regular equality for strings and other types.

  Let's perform an approximate equality comparison for two DataFrames that are not equal.

  ```python
  def test_approx_df_equality_different():
      data1 = [
          (1.1, "a"),
          (2.2, "b"),
          (3.3, "c"),
          (None, None)
      ]
      df1 = spark.createDataFrame(data1, ["num", "letter"])

      data2 = [
          (1.1, "a"),
          (5.0, "b"),
          (3.3, "z"),
          (None, None)
      ]
      df2 = spark.createDataFrame(data2, ["num", "letter"])

      assert_approx_df_equality(df1, df2, 0.1)
  ```

  Here's the pretty error message that's outputted:

  ![DataFramesNotEqualError](https://github.com/MrPowers/chispa/blob/main/images/dfs_not_approx_equal.png)



  DataFrame equality messages peform schema comparisons before analyzing the actual content of the DataFrames.  DataFrames that don't have the same schemas should error out as fast as possible.

  Let's compare a DataFrame that has a string column an integer column with a DataFrame that has two integer columns to observe the schema mismatch message.

  ```python
  def test_schema_mismatch_message():
      data1 = [
          (1, "a"),
          (2, "b"),
          (3, "c"),
          (None, None)
      ]
      df1 = spark.createDataFrame(data1, ["num", "letter"])

      data2 = [
          (1, 6),
          (2, 7),
          (3, 8),
          (None, None)
      ]
      df2 = spark.createDataFrame(data2, ["num", "num2"])

      assert_df_equality(df1, df2)
  ```

  Here's the error message:

  ![SchemasNotEqualError](https://github.com/MrPowers/chispa/blob/main/images/schemas_not_approx_equal.png)



  chispa currently supports PySpark 2.4+ and Python 3.5+.

  Use chispa v0.8.2 if you're using an older Python version.

  PySpark 2 support will be dropped when chispa 1.x is released.



  TODO: Need to benchmark these methods vs. the spark-testing-base ones



  You are encouraged to clone and/or fork this repo.

  This project uses [Poetry](https://python-poetry.org/) for packaging and dependency management.

  * Setup the virtual environment with `poetry install`
  * Run the tests with `poetry run pytest tests`

  Studying the codebase is a great way to learn about PySpark!



  Anyone is encouraged to submit a pull request, open an issue, or submit a bug report.

  We're happy to promote folks to be library maintainers if they make good contributions.


pkgId: 234c1f3c22aff011415bb5bf29b1925b0babbeb142913c330515a9f862b2ebaf
name: python-chkpkg
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Tests Python package sources to see if they build successfully to a PyPi compatible distribution
url: https://github.com/rtmigo/chkpkg_py#readme
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chkpkg-0.5.2-1.src.rpm
checksum_type: sha256
description:
  `chkpkg` supports Python 3.6+ on Linux, macOS and Windows.

  ``` bash
  pip3 install chkpkg
  ```

  ``` python3
  from chkpkg import Package
  with Package() as pkg:
      pkg.run_python_code('import mypackage; mypackage.myfunc()')
      pkg.run_shell_code('mypackage_cli --version')
  print("Package is OK!")
  ```
  This **test script** creates a distribution from project sources, installs the
  package from the distribution into a virtual environment, tries importing and
  running the installed package from python and command line.
  If any results in an error, an exception is thrown. The absence of exceptions
  means that the package is fine.
  By default, we assume that the `setup.py` or `setup.cfg` is located in the
  current working directory. You can specify a different path using the
  argument `Package(project_dir=...)`

  Without context, the test script would look like this:
  ``` python3
  from chkpkg import Package
  pkg = Package()
  try:
      
      pkg.init()
      
      pkg.run_python_code('import mypackage; mypackage.myfunc()')
      pkg.run_shell_code('mypackage_cli --version')
  finally:
      
      pkg.cleanup()
  ```

  ``` python3
  pkg.init()
  ```
  The `init` method:
  - Creates a temporary virtual environment capable of building `.whl` files
      - Creates a distribution as a `.whl` file (`python -m build`)
      - Verifies the package source (`twine check --strict`)
  - Creates another temporary virtual environment without preinstalled packages
      - Installs the package from the newly created `.whl` into the clean virtual
        environment

  ``` python3
  pkg.run_python_code('import mypackage')
  ```
  The `run_python_code` method allows you to check that the package is installed
  and can be imported without errors.
  You can also run some functions from the imported package and check the output.
  ``` python3
  output = pkg.run_python_code('import mypackage; print(mypackage.plus(2, 3))')
  assert output == "5"
  ```
  If the package must be installed as a CLI program, this can be tested with
  the `run_shell_code`. This function calls `cmd.exe` on Windows and `bash`
  on other systems.
  ``` python3
  output = pkg.run_shell_code('mypackage_cli --version')
  assert output[0].isdigit()
  ```
  The current working directory will be a random temporary one. If `mypackage_cli`
  can be run, then it really is available as a shell command from any directory.
  However, such tests are best done on a clean system. If we run the tests on
  development machine, it may turn out that we are running a command that was in
  the system before the package was installed.

  ``` python3
  pkg.cleanup()
  ```
  The `cleanup` method removes all temporary directories created during building
  and testing.

  Copyright © 2021 [Arteom iG](https://github.com/rtmigo).
  Released under the [MIT License](LICENSE).


pkgId: 8d638a430bab678b0884dc2ddd891bd4542a16b85bddaab351f9b0997141cd8f
name: python-chloris-app-sdk
arch: src
version: 1.0.13
epoch: 0
release: 1
summary: A package created with a setuptools tutorial. See article link for more details.
url: https://app.chloris.earth/docs/index.html
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chloris-app-sdk-1.0.13-1.src.rpm
checksum_type: sha256
description:
  The Chloris Platform Python SDK (_chloris-app-sdk_) is a Python package that provides a convenient interface to the Chloris Platform API. It is designed to be used by both humans and machines, but if you are a human you may find it easier to use the [Chloris Platform](https://app.chloris.earth/) web interface. Note that the API is only available for use with premium organizations, please contact us if you are interested in using the API.

  See the [API documentation](https://app.chloris.earth/docs/index.html) for more information about the Chloris Platform API.

  See the [Python API reference](./docs/index.md) for the full list of functions and classes available in the SDK.



  To install the Chloris Platform Python SDK run:

  ```bash
  pip install chloris_app_sdk
  ```





  The Chloris Platform API uses [OAuth 2.0](https://oauth.net/2/) for authentication. You can authenticate using either a refresh token or an ID token. Refresh tokens are long-lived and can be used to generate new ID tokens. ID tokens are short-lived and can be used directly for authentication. Refresh tokens are recommended for use in scripts and ID tokens are recommended for use in web applications.

  See the [Chloris Platform API documentation](https://app.chloris.earth/docs/index.html) for more information about authentication.



  Here is an example which lists active sites in your organization, then prints the annual stock for the first site, and then the average biomass density for 2015:

  ```python
  from chloris_app_sdk import ChlorisAppClient
  from chloris_app_sdk.utils import to_tco2e


  client = ChlorisAppClient(
      organization_id="your-organization-id",
      refresh_token="your-refresh-token", # env: CHLORIS_REFRESH_TOKEN
      
      
  )


  reporting_units = client.list_active_sites()
  stats = client.get_reporting_unit_stats(reporting_units[0])


  for i, year in enumerate(stats["annualYears"]):
      stock = to_tco2e(stats["annualStock"][i])
      print(f"{year}: {stock} tco₂e")


  i = stats["annualYears"].index(2015)
  biomass_density = stats["annualStock"][i] / (stats["annualAreaKm2"][i] * 100)
  print(f"Average biomass density in 2015: {biomass_density} t/ha")

  ```


pkgId: 2be06f9b60a10cb294cf563818438c9750167017ef8ff806a0efaeed38717997
name: python-chlorophyll
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: A module that fills your code with color - syntax highlighted text box widget for Tkinter.
url: https://github.com/rdbende/chlorophyll
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chlorophyll-0.4.2-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Chlorophyll</h1>

  > **Note**
  > This module is the successor to [`tkcode`](https://github.com/rdbende/tkcode), as it is deprecated - please do not use it any more.


  Chlorophyll provides the `CodeView` widget for tkinter, which is a `Text` widget with syntax highlighting, line numbers, and works as a simple code editor. It is written in Python and uses the [`pygments`](https://pygments.org/) library for syntax highlighting and the [`TkLineNums`](https://www.github.com/Moosems/TkLineNums) module for line numbers.


  `pip install chlorophyll`


  First, fork the repo, then run these commands in your terminal
  ```console
  git clone https://github.com/your-username/chlorophyll
  cd chlorophyll
  python3 -m venv env
  source env/bin/activate
  pip install -e .
  ```




  |Options             |Description                     |Input                                         |
  |--------------------|--------------------------------|----------------------------------------------|
  |master              |The parent widget               |Tkinter widget                                |
  |lexer               |The Language lexer              |Pygments lexer                                |
  |color_scheme        |A color scheme for the code     |Dict, string, or toml file                    |
  |tab_width           |The width of a tab (`\t`)       |Int                                           |
  |autohide_scrollbar  |Auto hide scrollbars            |Bool                                          |
  |linenums_border     |Border width of the line numbers|Int                                           |
  |default_context_menu|Enable context menus in CodeView|Bool                                          |
  |**kwargs            |Keyword arguments for the widget|Any keyword arguments given to a `Text` widget|


  ```python
  from tkinter import Tk

  import pygments.lexers
  from chlorophyll import CodeView

  root = Tk()

  codeview = CodeView(root, lexer=pygments.lexers.RustLexer, color_scheme="monokai")
  codeview.pack(fill="both", expand=True)

  root.mainloop()
  ```


pkgId: a08e73c9fea23057b8ddc92c0fa08a9a200767992a3f04b47c43b0185332440e
name: python-chmod
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Basic chmod conversion tool
url: https://pypi.org/project/chmod/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chmod-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/harrysharma1/chmod-calculator/actions/workflows/workflow.yml/badge.svg)](https://github.com/harrysharma1/chmod-calculator/actions/workflows/workflow.yml)

  This is a python module for calculating chmod.
  This is my first module so it will have some bugs.



  After running `pip install chmod`, you can use it in Python

  ```python
  import chmod
  a = chmod.ChmodConversion()

  print(a.int_to_perm(172))

  print(a.perm_to_int("--xrwx-w-"))
  ```


pkgId: 1ccaa9af841bfba3fc6bd52e153bbdc1583346e1f8088f7c2cad0cb1202773eb
name: python-chncal
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Check if some day is holiday in china.
url: https://github.com/Genlovy-Hoo/chncal
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chncal-2.3.1-1.src.rpm
checksum_type: sha256
description:
  判断某年某月某一天是不是工作日/节假日。

  修改自chinese_calendar：

  github: [chinese-calendar](https://github.com/LKI/chinese-calendar) , pypi: [chinese-calendar](https://pypi.org/project/chinesecalendar/)



  **在chinese_calendar的基础上增加了从2001到2003年的数据。**

  **增加了A股交易日和公历农历干支转换相关函数（日期参数均可传字符串或整数格式）：**

  get_recent_workday：最近的工作日

  get_next_nth_workday：往后（前）推n个工作日

  get_work_dates：取指定起止日期内的工作日列表

  is_tradeday：判断是否为沪深A股交易日

  get_recent_tradeday：最近交易日

  get_next_nth_tradeday：往后（前）推n个交易日

  get_trade_dates：取指定起止日期内的交易日期（周内的工作日）列表

  get_xingzuo：获取日期所属星座

  get_tgdz_year：计算（农历）年份天干地支

  gen2lun：公历日期转农历日期

  lun2gen：农历日期转普通日期（日期只能传字符串格式，形如'2023.02.30'）

  gen2gz：公历日期转干支纪日法

  get_tgdz_hour：公历时间（小时）转干支纪时法

  get_bazi：根据公历时间生成八字

  get_bazi_lunar：根据农历时间生成八字（时间只能传字符串格式，形如'2023.02.30 19:30:20'分和秒可以不写）

  fate_weight：称命，传入公历时间

  fate_weight_lunar：称命，传入农历时间（时间只能传字符串格式，形如'2023.02.30 19:30:20'分和秒可以不写）

  zodiac_match：生肖合婚信息

  get_zodiac_match：根据公历时间获取生肖合婚信息

  get_zodiac_match_lunar：根据农历时间获取生肖合婚信息（时间只能传字符串格式，形如'2023.02.30 19:30:20'时分秒可以不写）



  安装：

  ```
  pip install chncal --upgrade
  ```



  Github：

  [chncal](https://github.com/Genlovy-Hoo/chncal/)

  Pypi

  [chncal](https://pypi.org/project/chncal/)

  感谢使用和支持！


pkgId: 9bc0a1ad6dac2f3c44397cf693c119ce2af438532a2da4e5a93434b657f3133a
name: python-choclo
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Kernel functions for your geophysical models
url: https://pypi.org/project/choclo/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choclo-0.3.1-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/fatiando/choclo/raw/main/doc/_static/readme-banner.png" alt="Choclo">

  <h2 align="center">Kernel functions for your geophysical models</h2>

  <p align="center">
  <a href="https://www.fatiando.org/choclo"><strong>Documentation</strong> (latest)</a> •
  <a href="https://www.fatiando.org/choclo/dev"><strong>Documentation</strong> (main branch)</a> •
  <a href="https://github.com/fatiando/choclo/blob/main/CONTRIBUTING.md"><strong>Contributing</strong></a> •
  <a href="https://www.fatiando.org/contact/"><strong>Contact</strong></a>
  </p>

  <p align="center">
  Part of the <a href="https://www.fatiando.org"><strong>Fatiando
  a Terra</strong></a> project, built in collaboration with <a
  href="https://simpeg.xyz"><strong>SimPEG</strong></a>
  </p>

  <p align="center">
  <a href="https://pypi.python.org/pypi/choclo"><img src="http://img.shields.io/pypi/v/choclo.svg?style=flat-square" alt="Latest version on PyPI"></a>
  <a href="https://github.com/conda-forge/choclo-feedstock"><img src="https://img.shields.io/conda/vn/conda-forge/choclo.svg?style=flat-square" alt="Latest version on conda-forge"></a>
  <a href="https://codecov.io/gh/fatiando/choclo"><img src="https://img.shields.io/codecov/c/github/fatiando/choclo/main.svg?style=flat-square" alt="Test coverage status"></a>
  <a href="https://pypi.python.org/pypi/choclo"><img src="https://img.shields.io/pypi/pyversions/choclo.svg?style=flat-square" alt="Compatible Python versions."></a>
  <a href="https://doi.org/10.5281/zenodo.7851747"><img src="https://img.shields.io/badge/doi-10.5281%2Fzenodo.7851747-blue?style=flat-square" alt="DOI used to cite Choclo"></a>
  </p>



  **Choclo** is a Python library that hosts optimized kernel functions for
  running geophysical forward and inverse models, intended to be used by other
  libraries as the underlying layer of their computation.
  "Choclo" is a term used in some countries of South America to refer to corn,
  originated from the [quechua](https://en.wikipedia.org/wiki/Quechuan_languages)
  word _chuqllu_.



  * Provide optimized kernel functions for gravity and magnetic forward and
    inverse models that can be easily harnessed by different geophysical
    libraries.
  * Generate a pure-Python library that could be easily distributed and installed
    on any operating system.
  * Rely on [Numba](https://numba.pydata.org/) for just-in-time compilations and
    optional parallelization.
  * Keep the dependencies to the bare minimum to encourage other libraries to
    depend on Choclo.



  **Choclo is ready for use but still changing.**
  This means that we sometimes break backwards compatibility as we try to
  improve the software based on user experience, new ideas, better design
  decisions, etc. Please keep that in mind before you update Choclo to a newer
  version.

  **We welcome feedback and ideas!** This is a great time to bring new ideas on
  how we can improve the project.
  [Join the conversation](https://www.fatiando.org/contact) or submit
  [issues on GitHub](https://github.com/fatiando/choclo/issues).



  🗨️ **Contact us:**
  Find out more about how to reach us at
  [fatiando.org/contact](https://www.fatiando.org/contact/).

  👩🏾‍💻 **Contributing to project development:**
  Please read our
  [Contributing Guide](https://github.com/fatiando/choclo/blob/main/CONTRIBUTING.md)
  to see how you can help and give feedback.

  🧑🏾‍🤝‍🧑🏼 **Code of conduct:**
  This project is released with a
  [Code of Conduct](https://github.com/fatiando/community/blob/main/CODE_OF_CONDUCT.md).
  By participating in this project you agree to abide by its terms.

  > **Imposter syndrome disclaimer:**
  > We want your help. **No, really.** There may be a little voice inside your
  > head that is telling you that you're not ready, that you aren't skilled
  > enough to contribute. We assure you that the little voice in your head is
  > wrong. Most importantly, **there are many valuable ways to contribute besides
  > writing code**.
  >
  > *This disclaimer was adapted from the*
  > [MetPy project](https://github.com/Unidata/MetPy).



  This is free software: you can redistribute it and/or modify it under the terms
  of the **BSD 3-clause License**. A copy of this license is provided in
  [`LICENSE.txt`](https://github.com/fatiando/choclo/blob/main/LICENSE.txt).


pkgId: 19b2d79397bcf9e77f0cdf30c32e696c8ed2d7dfe424235a3b546ebd7d11d313
name: python-chocolate
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: An improvement to Python's kwargs
url: https://github.com/seungjaeryanlee/chocolate
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chocolate-0.0.2-1.src.rpm
checksum_type: sha256
description:
  **Chocolate** is a Python package that improves Python's `**kwargs`.

  ```python
  from chocolate import filter_args



  def example_function(arg1, arg2: int, arg3=3, arg4: str = ""):
      print(f"{arg1} {arg2} {arg3} {arg4}")


  kwargs = {"arg1": 1, "arg2": 2, "arg4": "4"}
  example_function(**kwargs)


  broken_kwargs = {"arg1": "This", "arg2": "does", "undefined_arg": "not", "arg3": "work"}
  try:
      example_function(**broken_kwargs)
  except Exception as exception:
      print(exception)


  example_function(**filter_args(broken_kwargs, example_function))
  ```


pkgId: 3cde090e3716051728483400be0520abc0d0fe18803ca7ecea019e994399c0ea
name: python-chocs
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Lightweight and powerful WSGI/AWS lambda framework for rapid building rest applications.
url: https://github.com/kodemore/chocs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chocs-1.6.1-1.src.rpm
checksum_type: sha256
description:
  <img align="right" width=300 src="https://github.com/kodemore/chocs/raw/master/chocs.png">



  Chocs is a modern HTTP framework for building AWS HTTP API/REST API and WSGI compatible applications.
  Chocs aims to be small, expressive, and robust.
  It provides an elegant API for writing fault-proof, extensible microservices.




   - AWS Serverless integration
   - Elegant and easy API
   - No additional bloat like built-in template engines, session handlers, etc.
   - Compatible with all WSGI servers
   - Loosely coupled components which can be used separately
   - Multipart body parsing
   - Graceful error handling
   - HTTP middleware support
   - Fast routing
   - Middleware packages to simplify daily tasks


  ```
  pip install chocs
  ```

  or with poetry

  ```
  poetry add chocs
  ```



  ```python
  import chocs

  http = chocs.Application()

  @http.get("/hello/{name}")
  def hello(request: chocs.HttpRequest) -> chocs.HttpResponse:
      return chocs.HttpResponse(f"Hello {request.path_parameters.get('name')}!")

  chocs.serve(http)
  ```

  > Keep in mind that the `chocs.serve()` function is using the `bjoern` package, so make sure you included it in your project
  > dependencies before using it. You are able to use any WSGI compatible server.





  Allows integrating OpenAPI documentation into your codebase, providing automating request validation based
  on your OpenAPI spec. More details are available in the [chocs-openapi repository](https://github.com/kodemore/chocs-openapi).



  Parsed body middleware helps to convert json/yaml request payloads into dataclass, this not only makes your
  daily tasks easier but increases readability of your code and contract. More details are available in the [chocs-parsed-body repository](https://github.com/kodemore/chocs-parsed-body).



  For usage and detailed documentation please visit our [wiki page](https://github.com/kodemore/chocs/wiki)


pkgId: 309c8559d8e88b5d5d5d40503b738393d1104f5e36868fb22506547ece275928
name: python-choice
arch: src
version: 0.1
epoch: 0
release: 1
summary: Easy request and response GUI for Python
url: https://github.com/fyhuang/choice
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choice-0.1-1.src.rpm
checksum_type: sha256
description:
  choice is a quick little library for getting user input in Python in a dialog-like fashion. Here's a little example:
  ~~~
  import choice

  confirm = choice.Binary('Are you sure you want to delete?', False).ask()
  if confirm:
      deleteIt()

  howmany = choice.Input('How many pies?', int).ask()
  print("You ordered {} pies".format(howmany))

  entree = choice.Menu(['steak', 'potatoes', 'eggplant']).ask()
  ~~~
  choice automatically displays the best UI available to the user: basic text console, curses, or GUI windows. (curses and GUI are in development!)


pkgId: f04fe75e4daa84cf84cdd7066c465bcf90d3b131596fc7ff032c838d2c5f0f00
name: python-choice-learn
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Large-scale choice modeling through the lens of machine learning.
url: https://github.com/artefactory/choice-learn
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choice-learn-1.1.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <picture>
    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_choice_learn.png">
    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/white_logo_choice_learn.png">
    <img src="https://raw.githubusercontent.com/artefactory/choice-learn/refs/heads/white_logo/docs/white_logo_choice_learn.png" width="300">
  </picture>

  *Large-scale choice modeling through the lens of machine learning*

  [![CI status](https://github.com/artefactory/choice-learn/actions/workflows/ci.yaml/badge.svg)](https://github.com/artefactory/choice-learn/actions/workflows/ci.yaml?query=branch%3Amain)
  [![Linting , formatting, imports sorting: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
  [![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-informational?logo=pre-commit&logoColor=white)](https://github.com/artefactory/choice-learn/blob/main/.pre-commit-config.yaml)


  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/choice-learn?logo=python)
  ![PyPI - Version](https://img.shields.io/pypi/v/choice-learn)
  ![PyPI - License](https://img.shields.io/pypi/l/choice-learn?color=purple)

  [![DOI](https://joss.theoj.org/papers/10.21105/joss.06899/status.svg)](https://doi.org/10.21105/joss.06899)
  [![cite](https://img.shields.io/badge/Citation-BibTeX-cyan)](./CITATION.bib)
  </div>


  Choice-Learn is a Python package designed to help you formulate, estimate, and deploy discrete choice models, e.g., for assortment planning.
  The package provides ready-to-use datasets and models studied in the academic literature. It also provides a lower level use if you wish to customize the specification of the choice model or formulate your own model from scratch. Choice-Learn efficiently handles large-scale choice data by limiting RAM usage.

  Choice-Learn uses NumPy and pandas as data backend engines and TensorFlow for models.


    - [Introduction - Discrete Choice modeling](#trident-introduction---discrete-choice-modeling)
    - [What's in there ?](#trident-whats-in-there-)
    - [Getting Started](#trident-getting-started)
    - [Installation](#trident-installation)
    - [Usage](#trident-usage)
    - [Documentation](#trident-documentation)
    - [Contributing](#trident-contributing)
    - [Citation](#trident-citation)
    - [References](#trident-references)



  Discrete choice models aim at explaining or predicting choices over a set of alternatives. Well known use-cases include analyzing people's choice of mean of transport or products purchases in stores.

  If you are new to choice modeling, you can check this [resource](https://www.publichealth.columbia.edu/research/population-health-methods/discrete-choice-model-and-analysis). The different notebooks from the [Getting Started](#trident-getting-started) section can also help you understand choice modeling and more importantly help you for your usecase.




  - The **ChoiceDataset** class can handle choice datasets with efficient memory management. It can be used on your own dataset. [[Example]](notebooks/introduction/2_data_handling.ipynb)
  - Many academic datasets are integrated in the library and ready to be used:

  | Dataset    | Raw Data | Origin | *from choice_learn.datasets import* | Doc |
  | ---------- | :----: | ------ | ------ | :---: |
  | SwissMetro  | [csv](./choice_learn/datasets/data/swissmetro.csv.gz)    | Bierlaire et al. (2001) [[2]](#trident-references) | *load_swissmetro* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_swissmetro) |
  | ModeCanada | [csv](./choice_learn/datasets/data/ModeCanada.csv.gz) | Forinash and Koppelman (1993) [[3]](#trident-references) | *load_modecanada* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_modecanada) |
  | Train    | [csv](./choice_learn/datasets/data/train_data.csv.gz) | Ben-Akiva et al. (1993) [[5]](#trident-references) |*load_train* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_train) |
  | Heating | [csv](./choice_learn/datasets/data/heating_data.csv.gz) | Kenneth Train's [website](https://eml.berkeley.edu/~train/) | *load_heating* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_heating) |
  | HC | [csv](./choice_learn/datasets/data/HC.csv.gz) | Kenneth Train's [website](https://eml.berkeley.edu/~train/) | *load_hc* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_hc) |
  | Electricity | [csv](./choice_learn/datasets/data/electricity.csv.gz) | Kenneth Train's [website](https://eml.berkeley.edu/~train/) | *load_electricity* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_electricity) |
  | Stated Car Preferences | [csv](./choice_learn/datasets/data/car.csv.gz) | McFadden and Train (2000) [[9]](#trident-references) | *load_car_preferences* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_car_preferences) |
  | TaFeng Grocery Dataset | [csv](./choice_learn/datasets/data/ta_feng.csv.zip) | [Kaggle](https://www.kaggle.com/datasets/chiranjivdas09/ta-feng-grocery-dataset) | *load_tafeng* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_tafeng/) |
  | ICDM-2013 Expedia | [url](https://www.kaggle.com/c/expedia-personalized-sort) |  Ben Hamner and Friedman (2013) [[6]](#trident-references) | *load_expedia* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_expedia/) |
  | London Passenger Mode Choice | [url]() | Hillel et al. (2018) [[11]](#trident-references) | *load_londonpassenger* | [#](https://artefactory.github.io/choice-learn/references/datasets/references_base/#choice_learn.datasets.base.load_londonpassenger) |



  - Different models are already implemented. You can import and parametrize the models for your own usage.
  - Otherwise, **custom modeling** is made easy by subclassing the ChoiceModel class and specifying your own utility function. [[Example]](notebooks/introduction/4_model_customization.ipynb)

  *List of implemented & ready-to-use models:*
  | Model | Example | Colab | Related Paper | *from choice_learn.models import* | Doc |
  | ---------- | -------- | -------- | ------ | ------ | :---: |
  | MNL | [notebook](notebooks/models/simple_mnl.ipynb) | [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/simple_mnl.ipynb) | | *SimpleMNL* | [#](https://artefactory.github.io/choice-learn/references/models/references_simple_mnl/) |
  | Conditional Logit  | [notebook](notebooks/introduction/3_model_clogit.ipynb)    | [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/introduction/3_model_clogit.ipynb) | Train et al. [[4]](#trident-references) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;| *ConditionalLogit* | [#](https://artefactory.github.io/choice-learn/references/models/references_clogit/) |
  | Nested Logit | [notebook](notebooks/models/nested_logit.ipynb) | [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/nested_logit.ipynb) | McFadden [[10]](#trident-references)  | *NestedLogit* | [#](https://artefactory.github.io/choice-learn/references/models/references_nested_logit/) |
  | Latent Class MNL    | [notebook](notebooks/models/latent_class_model.ipynb) | [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/latent_class_model.ipynb) | | *LatentClassConditionalLogit* | [#](LatentClassConditionalLogit) |

  | NN-based Model    | Example | Colab | Related Paper | *from choice_learn.models import* | Doc |
  | ---------- | -------- | ------ | ---- | ------ | :---: |
  | RUMnet| [notebook](notebooks/models/rumnet.ipynb) |  [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/rumnet.ipynb) |Aouad and Désir [[1]](#trident-references) | *RUMnet* | [#](https://artefactory.github.io/choice-learn/references/models/references_rumnet/#choice_learn.models.rumnet.PaperRUMnet) |
  | TasteNet | [notebook](notebooks/models/tastenet.ipynb) |  [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/tastenet.ipynb) |Han et al. [[7]](#trident-references) | *TasteNet* | [#](https://artefactory.github.io/choice-learn/references/models/references_tastenet/) |
  | Learning-MNL | [notebook](notebooks/models/learning_mnl.ipynb) |  [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/learning_mnl.ipynb) |Sifringer et al. [[13]](#trident-references) | *LearningMNL* | [#](https://artefactory.github.io/choice-learn/references/models/references_learning_mnl/) |
  | ResLogit | [notebook](notebooks/models/reslogit.ipynb) |  [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/models/reslogit.ipynb) |Wong and Farooq [[12]](#trident-references) | *ResLogit*  | [#](https://artefactory.github.io/choice-learn/references/models/references_reslogit/) |



  Algorithms leveraging choice models are integrated within the library:
  - Assortment & Pricing optimization algorithms [[Example]](notebooks/auxiliary_tools/assortment_example.ipynb) [[8]](#trident-references) [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/auxiliary_tools/assortment_example.ipynb)



  You can find the following tutorials to help you getting started with the package:
  - Generic and simple introduction [[notebook]](notebooks/introduction/1_introductive_example.ipynb)[[doc]](https://expert-dollop-1wemk8l.pages.github.io/notebooks/introduction/1_introductive_example/) [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab
  )](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/introduction/1_introductive_example.ipynb)
  - Detailed explanations of data handling depending on the data format [[noteboook]](notebooks/introduction/2_data_handling.ipynb)[[doc]](https://expert-dollop-1wemk8l.pages.github.io/notebooks/introduction/2_data_handling/)  [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/introduction/2_data_handling.ipynb)
  - A detailed example of conditional logit estimation [[notebook]](notebooks/introduction/3_model_clogit.ipynb)[[doc]](https://expert-dollop-1wemk8l.pages.github.io/notebooks/introduction/3_model_clogit/)  [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/introduction/3_model_clogit.ipynb)
  - Introduction to custom modeling and more complex parametrization [[notebook]](notebooks/introduction/4_model_customization.ipynb)[[doc]](https://expert-dollop-1wemk8l.pages.github.io/notebooks/introduction/4_model_customization/) [![Open In Colab](https://img.shields.io/badge/-grey?logo=googlecolab)](https://colab.research.google.com/github/artefactory/choice-learn/blob/main/notebooks/introduction/4_model_customization.ipynb)
  - All models and algorithms have a companion example in the notebook [directory](./notebooks/)





  To install the required packages in a virtual environment, run the following command:

  The easiest is to pip-install the package:
  ```bash
  pip install choice-learn
  ```

  Otherwise you can use the git repository to get the latest version:
  ```bash
  git clone git@github.com:artefactory/choice-learn.git
  ```


  For manual installation, Choice-Learn requires the following:
  - Python (>=3.9, <3.13)
  - NumPy (>=1.24)
  - pandas (>=1.5)

  For modeling you need:
  - TensorFlow (>=2.14, <2.17)

  > :warning: **Warning:** If you are a MAC user with a M1 or M2 chip, importing TensorFlow might lead to Python crashing.
  > In such case, use anaconda to install TensorFlow with `conda install -c apple tensorflow`.

  An optional requirement used for coefficients analysis and L-BFGS optimization is:
  - TensorFlow Probability (>=0.22)

  Finally for pricing or assortment optimization, you need either Gurobi or OR-Tools:
  - gurobipy (>=11.0)
  - ortools (>=9.6)

  <p align="center">
    <a href="https://numpy.org/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/numpy_logo.png" width="60" />
    </a>
    &nbsp;
    &nbsp;
    <a href="https://pandas.pydata.org/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/pandas_logo.png" width="60" />
    </a>
    &nbsp;
    &nbsp;
    <a href="https://www.tensorflow.org">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/tf_logo.png" width="60" />
    </a>
    &nbsp;
    &nbsp;
    <a href="https://www.gurobi.com/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/gurobi_logo.png" width="60" />
    </a>
    &nbsp;
    &nbsp;
    <a href="https://developers.google.com/optimization?hl=fr">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/or_tools_logo.png" width="70" />
    </a>
  </p>

  > :bulb: **Tip:** You can use the poetry.lock or requirements-complete.txt files with poetry or pip to install a fully predetermined and working environment.


  Here is a short example of model parametrization to estimate a Conditional Logit on the ModeCanada dataset.

  ```python
  from choice_learn.data import ChoiceDataset
  from choice_learn.models import ConditionalLogit, RUMnet
  from choice_learn.datasets import load_modecanada

  transport_df = load_modecanada(as_frame=True)

  dataset = ChoiceDataset.from_single_long_df(df=transport_df,
                                              items_id_column="alt",
                                              choices_id_column="case",
                                              choices_column="choice",
                                              shared_features_columns=["income"],
                                              items_features_columns=["cost", "freq", "ovt", "ivt"],
                                              choice_format="one_zero")


  model = ConditionalLogit()





  model.add_coefficients(feature_name="intercept",
                         items_indexes=[1, 2, 3])
  model.add_coefficients(feature_name="income",
                         items_indexes=[1, 2, 3])
  model.add_coefficients(feature_name="ivt",
                         items_indexes=[0, 1, 2, 3])



  model.add_shared_coefficient(feature_name="cost",
                               items_indexes=[0, 1, 2, 3])
  model.add_shared_coefficient(feature_name="freq",
                               items_indexes=[0, 1, 2, 3])
  model.add_shared_coefficient(feature_name="ovt",
                               items_indexes=[0, 1, 2, 3])

  history = model.fit(dataset, get_report=True)
  print("The average neg-loglikelihood is:", model.evaluate(dataset).numpy())
  print(model.report)
  ```



  A detailed documentation of this project is available [here](https://artefactory.github.io/choice-learn/).\
  TensorFlow also has extensive [documentation](https://www.tensorflow.org/) that can help you.\
  An academic paper has been published in the Journal of Open-Source Software, [here](https://joss.theoj.org/papers/10.21105/joss.06899).


  You are welcome to contribute to the project ! You can help in various ways:
  - raise issues
  - resolve issues already opened
  - develop new features
  - provide additional examples of use
  - fix typos, improve code quality
  - develop new tests

  We recommend to first open an [issue](https://github.com/artefactory/choice-learn/issues) to discuss your ideas. More details are given [here](./CONTRIBUTING.md).



  If you consider this package and any of its feature useful for your research, consider citing our [paper](https://joss.theoj.org/papers/10.21105/joss.06899).

  <a href="https://joss.theoj.org/papers/10.21105/joss.06899">
  <img align="left" width="100"src="https://github.com/openjournals/joss/blob/main/docs/logos/joss-logo.png?raw=true" />
  </a>

  ```bash
  @article{Auriau2024,
    doi = {10.21105/joss.06899},
    url = {https://doi.org/10.21105/joss.06899},
    year = {2024},
    publisher = {The Open Journal},
    volume = {9},
    number = {101},
    pages = {6899},
    author = {Vincent Auriau and Ali Aouad and Antoine Désir and Emmanuel Malherbe},
    title = {Choice-Learn: Large-scale choice modeling for operational contexts through the lens of machine learning},
    journal = {Journal of Open Source Software} }
  ```



  The use of this software is under the MIT license, with no limitation of usage, including for commercial applications.



  Choice-Learn has been developed through a collaboration between researchers at the Artefact Research Center and the laboratory MICS from CentraleSupélec, Université Paris Saclay.

  <p align="center">
    <a href="https://www.artefact.com/data-consulting-transformation/artefact-research-center/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_arc.png" height="60" />
    </a>
    &emsp;
    &emsp;
    <a href="https://www.artefact.com/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_atf.png" height="65" />
    </a>
  </p>

  <p align="center">
    <a href="https://www.universite-paris-saclay.fr/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_paris_saclay.png" height="60" />
    </a>
    &emsp;
    &emsp;
    <a href="https://mics.centralesupelec.fr/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_CS.png" height="60" />
    </a>
    &emsp;
    &emsp;
    <a href="https://www.london.edu/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_lbs.jpeg" height="60" />
    </a>
    &emsp;
    &emsp;
    <a href="https://www.insead.edu/">
      <img src="https://raw.githubusercontent.com/artefactory/choice-learn/main/docs/illustrations/logos/logo_insead.png" height="60" />
    </a>
  </p>




  [1][Representing Random Utility Choice Models with Neural Networks](https://arxiv.org/abs/2207.12877), Aouad, A.; Désir, A. (2022)\
  [2][The Acceptance of Model Innovation: The Case of Swissmetro](https://www.researchgate.net/publication/37456549_The_acceptance_of_modal_innovation_The_case_of_Swissmetro), Bierlaire, M.; Axhausen, K., W.; Abay, G. (2001)\
  [3][Applications and Interpretation of Nested Logit Models of Intercity Mode Choice](https://trid.trb.org/view/385097), Forinash, C., V.; Koppelman, F., S. (1993)\
  [4][The Demand for Local Telephone Service: A Fully Discrete Model of Residential Calling Patterns and Service Choices](https://www.jstor.org/stable/2555538), Train K., E.; McFadden, D., L.; Moshe, B. (1987)\
  [5] [Estimation of Travel Choice Models with Randomly Distributed Values of Time](https://ideas.repec.org/p/fth/lavaen/9303.html), Ben-Akiva, M.; Bolduc, D.; Bradley, M. (1993)\
  [6] [Personalize Expedia Hotel Searches - ICDM 2013](https://www.kaggle.com/c/expedia-personalized-sort), Ben Hamner, A.; Friedman, D.; SSA_Expedia. (2013)\
  [7] [A Neural-embedded Discrete Choice Model: Learning Taste Representation with Strengthened Interpretability](https://arxiv.org/abs/2002.00922), Han, Y.; Calara Oereuran F.; Ben-Akiva, M.; Zegras, C. (2020)\
  [8] [A branch-and-cut algorithm for the latent-class logit assortment problem](https://www.sciencedirect.com/science/article/pii/S0166218X12001072), Méndez-Díaz, I.; Miranda-Bront, J. J.; Vulcano, G.; Zabala, P. (2014)\
  [9] [Stated Preferences for Car Choice in Mixed MNL models for discrete response.](https://www.jstor.org/stable/2678603), McFadden, D. and Kenneth Train (2000)\
  [10] [Modeling the Choice of Residential Location](https://onlinepubs.trb.org/Onlinepubs/trr/1978/673/673-012.pdf), McFadden, D. (1978)\
  [11] [Recreating passenger mode choice-sets for transport simulation: A case study of London, UK](https://www.icevirtuallibrary.com/doi/10.1680/jsmic.17.00018), Hillel, T.; Elshafie, M. Z. E. B.; Jin, Y. (2018)\
  [12] [ResLogit: A residual neural network logit model for data-driven choice modelling](https://doi.org/10.1016/j.trc.2021.103050), Wong, M.; Farooq, B. (2021)\
  [13] [Enhancing Discrete Choice Models with Representation Learning](https://arxiv.org/abs/1812.09747), Sifringer, B.; Lurkin, V.; Alahi, A. (2018)



  *Official models implementations:*

  [1] [RUMnet](https://github.com/antoinedesir/rumnet)\
  [7] TasteNet [[Repo1](https://github.com/YafeiHan-MIT/TasteNet-MNL)] [[Repo2](https://github.com/deborahmit/TasteNet-MNL)]\
  [12] [ResLogit](https://github.com/LiTrans/reslogit)\
  [13] [Learning-MNL](https://github.com/BSifringer/EnhancedDCM)


pkgId: 9c7d8ba7525871cac470b403e0c24f684600552e5f690c504eff7156d651ac87
name: python-choix
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Inference algorithms for models based on Luce's choice axiom.
url: https://github.com/lucasmaystre/choix
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choix-0.3.5-1.src.rpm
checksum_type: sha256
description:
  |build-status| |coverage| |docs|
  ``choix`` is a Python library that provides inference algorithms for models
  based on Luce's choice axiom. These probabilistic models can be used to explain
  and predict outcomes of comparisons between items.
  - **Pairwise comparisons**: when the data consists of comparisons between two
    items, the model variant is usually referred to as the *Bradley-Terry* model.
    It is closely related to the Elo rating system used to rank chess players.
  - **Partial rankings**: when the data consists of rankings over (a subset of)
    the items, the model variant is usually referred to as the *Plackett-Luce*
    model.
  - **Top-1 lists**: another variation of the model arises when the data consists
    of discrete choices, i.e., we observe the selection of one item out of a
    subset of items.
  - **Choices in a network**: when the data consists of counts of the number of
    visits to each node in a network, the model is known as the *Network Choice
    Model*.
  ``choix`` makes it easy to infer model parameters from these different types of
  data, using a variety of algorithms:
  - Luce Spectral Ranking
  - Minorization-Maximization
  - Rank Centrality
  - Approximate Bayesian inference with expectation propagation


pkgId: 0b357211e7d82050e22236428cce746e87ff8c7189dd25a24b3a486d6f8c5990
name: python-chomper
arch: src
version: 0.3.3
epoch: 0
release: 1
url: https://pypi.org/project/chomper/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chomper-0.3.3-1.src.rpm
checksum_type: sha256
summary:
  A lightweight emulation framework for emulating security algorithms of iOS executables and libraries.

description:
  [![build](https://github.com/sledgeh4w/chomper/actions/workflows/tests.yml/badge.svg)](https://github.com/sledgeh4w/chomper/actions/workflows/tests.yml)
  ![PyPI](https://img.shields.io/pypi/v/chomper)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chomper)
  [![GitHub license](https://img.shields.io/github/license/sledgeh4w/chomper)](https://github.com/sledgeh4w/chomper/blob/main/LICENSE)

  Chomper is a lightweight emulation framework based on [Unicorn](https://github.com/unicorn-engine/unicorn). It is mainly used to emulate security algorithms of iOS executables and libraries. In addition, it also provides limited support for Android native libraries.



  - Basic emulation for ELF and Mach-O
  - Support for a set of iOS system libraries (from iOS 14.4.0)



  - Python 3.8+
  - Unicorn 2.0.0+



  ```
  $ pip install chomper
  ```



  Emulate iOS executables.

  ```python
  import uuid

  from chomper import Chomper
  from chomper.const import ARCH_ARM64, OS_IOS


  emu = Chomper(
      arch=ARCH_ARM64,
      os_type=OS_IOS,
      rootfs_path="examples/rootfs/ios",
  )


  duapp = emu.load_module("examples/binaries/ios/com.siwuai.duapp/DUApp")

  s = "chomper"


  a1 = emu.create_string("objc")
  a2 = emu.create_string(s)
  a3 = len(s)
  a4 = emu.create_string(str(uuid.uuid4()))
  a5 = emu.create_buffer(8)
  a6 = emu.create_buffer(8)
  a7 = emu.create_string("com.siwuai.duapp")


  emu.call_address(duapp.base + 0x109322118, a1, a2, a3, a4, a5, a6, a7)
  result = emu.read_string(emu.read_pointer(a5))
  ```

  Working with Objective-C.

  ```python
  from chomper import Chomper
  from chomper.const import ARCH_ARM64, OS_IOS
  from chomper.objc import ObjC

  emu = Chomper(
      arch=ARCH_ARM64,
      os_type=OS_IOS,
      rootfs_path="examples/rootfs/ios",
  )

  objc = ObjC(emu)

  emu.load_module("examples/binaries/ios/cn.com.scal.sichuanair/zsch")


  with objc.autorelease_pool():
      
      a1 = objc.msg_send("NSString", "stringWithUTF8String:", "test")

      
      req_sign = objc.msg_send("ZSCHRSA", "getReqSign:", a1)

      
      result_ptr = objc.msg_send(req_sign, "cStringUsingEncoding:", 4)
      result = emu.read_string(result_ptr)
  ```

  Emulate Android native libraries.

  ```python
  from chomper import Chomper
  from chomper.const import ARCH_ARM64, OS_ANDROID

  emu = Chomper(arch=ARCH_ARM64, os_type=OS_ANDROID)


  emu.load_module("examples/rootfs/android/system/lib64/libc.so")
  emu.load_module("examples/rootfs/android/system/lib64/libz.so")

  libszstone = emu.load_module(
      "examples/binaries/android/com.shizhuang.duapp/libszstone.so",
      exec_init_array=True,
  )

  s = "chomper"

  a1 = emu.create_string(s)
  a2 = len(s)
  a3 = emu.create_buffer(1024)

  result_size = emu.call_address(libszstone.base + 0x2F1C8, a1, a2, a3)
  result = emu.read_bytes(a3, result_size)
  ```


  There are some security algorithm emulation codes in the [examples](https://github.com/sledgeh4w/chomper/tree/main/examples), and you can download all example binary files from [SourceForge](https://sourceforge.net/projects/chomper-emu/files/examples/binaries/).


pkgId: 1b8b7be88e8dc19d4b8cfbd307f12aa065100698b3bf2019d833f10d620f99fc
name: python-chonker
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: A utility package for NLP and Machine Learning
url: https://github.com/cmdowney88/chonker
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chonker-1.4.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="logo.png" alt="Chonker Logo" width="225" height="200"></p>



  Welcome to Chonker! This code was assembled to provide a library to make data-intensive tasks just a little easier. Right now, Chonker is quite small: made up of one key module (wrangle) with one more currently in development (chonktorch). As a full-time student/researcher, 100% of this code develops from use in my ongoing projects. Chonker provides a neat package for myself and others who want to reuse convenient data functions instead of rebuilding them every time. If you somehow happen upon this library, I hope that something in here may be of use to you too!



  A module containing classes and functions designed to streamline data pre- and post-processing (i.e. wrangling)

  A module for pre-built neural models for NLP, based off of my research and built on PyTorch


  Chonker is a work-in-progress with few guarantees. However, it is also open source and free to be modified and distributed, as long as those modifications remain free. As such, Chonker is licensed by the <a href=https://www.mozilla.org/en-US/MPL/2.0/FAQ>Mozilla Public License 2.0</a>.


  C.M. Downey

  *cmdowney@uw.edu*

  PhD Student

  Department of Linguistics

  University of Washington


pkgId: c55f2c42d09bc6b0d11adfec103ac2892ef72c59c85876efb68b30f0552198eb
name: python-chonkie
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: 🦛 CHONK your texts with Chonkie ✨ - The no-nonsense RAG chunking library
url: https://github.com/bhavnicksm/chonkie
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chonkie-0.2.0-1.src.rpm
checksum_type: sha256
description:
  <div align='center'>

  ![Chonkie Logo](/assets/chonkie_logo_br_transparent_bg.png)



  [![PyPI version](https://img.shields.io/pypi/v/chonkie.svg)](https://pypi.org/project/chonkie/)
  [![License](https://img.shields.io/github/license/bhavnicksm/chonkie.svg)](https://github.com/bhavnicksm/chonkie/blob/main/LICENSE)
  [![Documentation](https://img.shields.io/badge/docs-DOCS.md-blue.svg)](DOCS.md)
  ![Package size](https://img.shields.io/badge/size-9.7MB-blue)
  [![Downloads](https://static.pepy.tech/badge/chonkie)](https://pepy.tech/project/chonkie)
  [![GitHub stars](https://img.shields.io/github/stars/bhavnicksm/chonkie.svg)](https://github.com/bhavnicksm/chonkie/stargazers)

  _The no-nonsense RAG chunking library that's lightweight, lightning-fast, and ready to CHONK your texts_

  [Installation](#installation) •
  [Usage](#usage) •
  [Supported Methods](#supported-methods) •
  [Benchmarks](#benchmarks-️) •
  [Acknowledgements](#acknowledgements) •
  [Citation](#citation)

  </div>

  so i found myself making another RAG bot (for the 2342148th time) and meanwhile, explaining to my juniors about why we should use chunking in our RAG bots, only to realise that i would have to write chunking all over again unless i use the bloated software library X or the extremely feature-less library Y. _WHY CAN I NOT HAVE SOMETHING JUST RIGHT, UGH?_

  Can't i just install, import and run chunking and not have to worry about dependencies, bloat, speed or other factors?

  Well, with chonkie you can! (chonkie boi is a gud boi)

  **🚀 Feature-rich**: All the CHONKs you'd ever need </br>
  **✨ Easy to use**: Install, Import, CHONK </br>
  **⚡ Fast**: CHONK at the speed of light! zooooom </br>
  **🌐 Wide support**: Supports all your favorite tokenizer CHONKS </br>
  **🪶 Light-weight**: No bloat, just CHONK </br>
  **🦛 Cute CHONK mascot**: psst it's a pygmy hippo btw </br>
  **❤️ [Moto Moto](#acknowledgements)'s favorite python library** </br>

  What're you waiting for, **just CHONK it**!



  To install chonkie, simply run:

  ```bash
  pip install chonkie
  ```

  Chonkie follows the rule to have minimal defualt installs, read the [DOCS](/DOCS.md) to know the installation for your required chunker, or simply install `all` if you don't want to think about it (not recommended).

  ```bash
  pip install chonkie[all]
  ```



  Here's a basic example to get you started:

  ```python

  from chonkie import TokenChunker



  from tokenizers import Tokenizer
  tokenizer = Tokenizer.from_pretrained("gpt2")


  chunker = TokenChunker(tokenizer)


  chunks = chunker("Woah! Chonkie, the chunking library is so cool! I love the tiny hippo hehe.")


  for chunk in chunks:
      print(f"Chunk: {chunk.text}")
      print(f"Tokens: {chunk.token_count}")
  ```

  More example usages given inside the [DOCS](/DOCS.md)



  Chonkie provides several chunkers to help you split your text efficiently for RAG applications. Here's a quick overview of the available chunkers:

  - **TokenChunker**: Splits text into fixed-size token chunks.
  - **WordChunker**: Splits text into chunks based on words.
  - **SentenceChunker**: Splits text into chunks based on sentences.
  - **SemanticChunker**: Splits text into chunks based on semantic similarity.
  - **SDPMChunker**: Splits text using a Semantic Double-Pass Merge approach.

  More on these methods and the approaches taken inside the [DOCS](/DOCS.md)



  > "I may be smol hippo, but I pack a punch!" 🦛

  Here's a quick peek at how Chonkie performs:

  **Size**📦

  - **Default Install:** 9.7MB (vs 80-171MB for alternatives)
  - **With Semantic:** Still lighter than the competition!

  **Speed**⚡

  - **Token Chunking:** 33x faster than the slowest alternative
  - **Sentence Chunking:** Almost 2x faster than competitors
  - **Semantic Chunking:** Up to 2.5x faster than others

  Check out our detailed [benchmarks](/benchmarks/README.md) to see how Chonkie races past the competition! 🏃‍♂️💨



  Chonkie would like to CHONK its way through a special thanks to all the users and contributors who have helped make this library what it is today! Your feedback, issue reports, and improvements have helped make Chonkie the CHONKIEST it can be.

  And of course, special thanks to [Moto Moto](https://www.youtube.com/watch?v=I0zZC4wtqDQ&t=5s) for endorsing Chonkie with his famous quote:
  > "I like them big, I like them chonkie."
  >                                         ~ Moto Moto



  If you use Chonkie in your research, please cite it as follows:

  ```
  @misc{chonkie2024,
    author = {Minhas, Bhavnick},
    title = {Chonkie: A Fast Feature-full Chunking Library for RAG Bots},
    year = {2024},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/bhavnick/chonkie}},
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Bhavnick Minhas  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: fa2cfab29b151fd1f879f9d28737275410e060322a8a816942a2e5ca15a176ed
name: python-chonkie
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: 🦛 CHONK your texts with Chonkie ✨ - The no-nonsense RAG chunking library
url: https://github.com/bhavnicksm/chonkie
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chonkie-0.2.2-1.src.rpm
checksum_type: sha256
description:
  <div align='center'>

  ![Chonkie Logo](/assets/chonkie_logo_br_transparent_bg.png)



  [![PyPI version](https://img.shields.io/pypi/v/chonkie.svg)](https://pypi.org/project/chonkie/)
  [![License](https://img.shields.io/github/license/bhavnicksm/chonkie.svg)](https://github.com/bhavnicksm/chonkie/blob/main/LICENSE)
  [![Documentation](https://img.shields.io/badge/docs-chonkie.ai-blue.svg)](https://docs.chonkie.ai)
  ![Package size](https://img.shields.io/badge/size-9.7MB-blue)
  [![Downloads](https://static.pepy.tech/badge/chonkie)](https://pepy.tech/project/chonkie)
  [![GitHub stars](https://img.shields.io/github/stars/bhavnicksm/chonkie.svg)](https://github.com/bhavnicksm/chonkie/stargazers)

  _The no-nonsense RAG chunking library that's lightweight, lightning-fast, and ready to CHONK your texts_

  [Installation](#installation) •
  [Usage](#usage) •
  [Supported Methods](#supported-methods) •
  [Benchmarks](#benchmarks-️) •
  [Documentation](https://docs.chonkie.ai) •
  [Citation](#citation)

  </div>

  so i found myself making another RAG bot (for the 2342148th time) and meanwhile, explaining to my juniors about why we should use chunking in our RAG bots, only to realise that i would have to write chunking all over again unless i use the bloated software library X or the extremely feature-less library Y. _WHY CAN I NOT HAVE SOMETHING JUST RIGHT, UGH?_

  Can't i just install, import and run chunking and not have to worry about dependencies, bloat, speed or other factors?

  Well, with chonkie you can! (chonkie boi is a gud boi)

  **🚀 Feature-rich**: All the CHONKs you'd ever need </br>
  **✨ Easy to use**: Install, Import, CHONK </br>
  **⚡ Fast**: CHONK at the speed of light! zooooom </br>
  **🌐 Wide support**: Supports all your favorite tokenizer CHONKS </br>
  **🪶 Light-weight**: No bloat, just CHONK </br>
  **🦛 Cute CHONK mascot**: psst it's a pygmy hippo btw </br>
  **❤️ [Moto Moto](#acknowledgements)'s favorite python library** </br>

  What're you waiting for, **just CHONK it**!



  To install chonkie, simply run:

  ```bash
  pip install chonkie
  ```

  Chonkie follows the rule to have minimal defualt installs, read the [DOCS](https://docs.chonkie.ai) to know the installation for your required chunker, or simply install `all` if you don't want to think about it (not recommended).

  ```bash
  pip install chonkie[all]
  ```



  Here's a basic example to get you started:

  ```python

  from chonkie import TokenChunker



  from tokenizers import Tokenizer
  tokenizer = Tokenizer.from_pretrained("gpt2")


  chunker = TokenChunker(tokenizer)


  chunks = chunker("Woah! Chonkie, the chunking library is so cool! I love the tiny hippo hehe.")


  for chunk in chunks:
      print(f"Chunk: {chunk.text}")
      print(f"Tokens: {chunk.token_count}")
  ```

  More example usages given inside the [DOCS](https://docs.chonkie.ai)



  Chonkie provides several chunkers to help you split your text efficiently for RAG applications. Here's a quick overview of the available chunkers:

  - **TokenChunker**: Splits text into fixed-size token chunks.
  - **WordChunker**: Splits text into chunks based on words.
  - **SentenceChunker**: Splits text into chunks based on sentences.
  - **SemanticChunker**: Splits text into chunks based on semantic similarity.
  - **SDPMChunker**: Splits text using a Semantic Double-Pass Merge approach.

  More on these methods and the approaches taken inside the [DOCS](https://docs.chonkie.ai)



  > "I may be smol hippo, but I pack a punch!" 🦛

  Here's a quick peek at how Chonkie performs:

  **Size**📦

  - **Default Install:** 9.7MB (vs 80-171MB for alternatives)
  - **With Semantic:** Still lighter than the competition!

  **Speed**⚡

  - **Token Chunking:** 33x faster than the slowest alternative
  - **Sentence Chunking:** Almost 2x faster than competitors
  - **Semantic Chunking:** Up to 2.5x faster than others

  Check out our detailed [benchmarks](https://docs.chonkie.ai/benchmarks) to see how Chonkie races past the competition! 🏃‍♂️💨



  Chonkie would like to CHONK its way through a special thanks to all the users and contributors who have helped make this library what it is today! Your feedback, issue reports, and improvements have helped make Chonkie the CHONKIEST it can be.

  And of course, special thanks to [Moto Moto](https://www.youtube.com/watch?v=I0zZC4wtqDQ&t=5s) for endorsing Chonkie with his famous quote:
  > "I like them big, I like them chonkie."
  >                                         ~ Moto Moto




  If you use Chonkie in your research, please cite it as follows:

  ```
  @misc{chonkie2024,
    author = {Minhas, Bhavnick},
    title = {Chonkie: A Fast Feature-full Chunking Library for RAG Bots},
    year = {2024},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/bhavnick/chonkie}},
  }
  ```

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


pkgId: a69e7bba57e70226f14b57cd8039ff9daaac96d21bc75cd8ab6db50f90c174e4
name: python-choochoo
arch: src
version: 0.41.1
epoch: 0
release: 1
summary: Data Science for Training
url: https://github.com/andrewcooke/choochoo
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choochoo-0.41.1-1.src.rpm
checksum_type: sha256
description:
  An **open**, **hackable** and **free** training diary.

  See [documentation](https://andrewcooke.github.io/choochoo/) for full
  details.

  Source and screenshots on [github](https://github.com/andrewcooke/choochoo).


pkgId: b9915920039f495fa4fdce4728d19aa92bec4a367ea78a693d394802719c8370
name: python-chope
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: CSS & HTML on Python Easily
url: https://github.com/hanstjua/chope
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chope-0.5.2-1.src.rpm
checksum_type: sha256
description:
  CSS &amp; HTML on Python Easily.

  ![PyPI](https://img.shields.io/pypi/v/chope)
  ![Pepy Total Downlods](https://img.shields.io/pepy/dt/chope)
  ![GitHub](https://img.shields.io/github/license/hanstjua/chope)
  ![GitHub Workflow Status (with branch)](https://img.shields.io/github/actions/workflow/status/hanstjua/chope/run_tests.yml?branch=main)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chope?label=python)

  Chope is a library that aims to provide a HTML and CSS domain-specific language (DSL) for Python.
  It draws inspiration from Clojure's [Hiccup](https://github.com/weavejester/hiccup) and JavaScript's [Emotion](https://emotion.sh/docs/introduction).


  * [Install](#install)
  * [Syntax](#syntax)
      * [HTML](#html)
          * [Creating Custom Elements](#creating-custom-elements)
      * [CSS](#css)
          * [Units](#units)
  * [Render](#render)
  * [Building a Template](#building-a-template)
      * [Factory Function](#factory-function)
      * [Variable Object](#variable-object)

  <a name="install" />



  Chope can be installed through pip.

  `pip install chope`

  <a name="syntax" />



  Here is a basic example of Chope syntax:

  ```python
  from chope import *
  from chope.css import *

  page = html[
      head[
          style[
              Css[
                  'body': dict(
                      background_color='linen',
                      font_size=pt/12
                  ),
                  '.inner-div': dict(
                      color='maroon',
                      margin_left=px/40
                  )
              ]
          ]
      ],
      body[
          h1['Title'],
          div(class_='outer-div')[
              div(class_='inner-div')[
                  'Some content.'
              ]
          ]
      ]
  ]
  ```

  <a name="html" />



  Declaring an element is as simple as this:

  ```python


  div['content']
  ```

  Element attributes can be specified like so:

  ```python


  div(id='my-id', class_='my-class your-class')['This is key-value style.']
  ```

  Notice the `_` suffix in the `class_` attribute. This suffix is necessary for any attribute names that clashes with any Python keyword.

  You can also define `id` and `class` using CSS selector syntax:

  ```python


  div('#my-id.my-class.your-class', title='Title')['This is selector style.']
  ```

  For attributes with names that cannot be declared using the *key-value* style, you can use the *tuple* style.

  ```python


  div('my:attr', 'x',
      'ur-attr', 'y',
      'their[attr]', 'z')[
          'This is tuple style.'
      ]
  ```

  The different styles can be mixed as long as there is no duplicate attribute definition.

  ```python


  div('#my-id.class1.class2',
      'my:attr', 'x',
      'ur-attr', 'y',
      'their[attr]', 'z',
      title="Mix 'em up",
      subtitle="But don't get mixed up"
      )[
          'This mixed style is OK.'
      ]



  div('#my-id.class1.class2',
      'id', 'x',  # conflicts with 'id' defined in selector style
      'title', 'y',
      'their[attr]', 'z',
      title="Mix 'em up",  # conflicts with 'title' defined in tuple style
      subtitle="But don't get mixed up"
      )[
          'This mixed style is NOT OK.'
      ]
  ```

  Iterables can be used to generate a sequence of elements in the body of an element.

  ```python


  ul[
      [li[str(i)] for i in range(3)]
  ]
  ```

  <a name="creating-custom-elements" />



  If you want to create a custom element with a custom tag, simply inherit from the `Element` class.

  ```python
  from chope import Element


  class custom(Element):  ## class name will be used as tag name during rendering
      pass


  custom['some content.']  ## <custom>some content.</custom>
  ```

  Normally, you don't need to override any method of `Element`, but if you want to change how your element is rendered, you can override the `render()` method.

  <a name="css" />



  The CSS syntax in Chope is simply a mapping between CSS selector strings and declarations dictionaries.

  Here's how a simple CSS stylesheet looks like in Chope:

  ```python
  '''
  h1 {
      color: blue;
  }

  .my-class {
      background-color: linen;
      text-align: center;
  }
  '''

  Css[
      'h1': dict(
          color='blue'
      ),
      '.my-class': dict(
          background_color='linen',
          text_align='center'
      )
  ]



  Css[
      'h1': {
          'color': 'blue'
      },
      '.my-class': {
          'background-color': 'linen',
          'text-align': 'center'
      }
  ]
  ```

  When you do declarations using the `dict` constructor, any `_` will be converted to `-` automatically.

  If your attribute name actually contains an `_`, declare using dictionary literal instead.

  <a name="units" />



  Declaring size properties is very simple:

  ```python
  '''
  .my-class {
      font-size: 14px;
      margin: 20%;
  }
  '''

  Css[
      '.my-class': dict(
          font_size=px/14,
          margin=percent/20
      )
  ]
  ```

  Chope supports standard HTML units. (e.g.`em`, `rem`, `pt`, etc.)

  To set properties with multiple values, simply pass an iterable or a string.

  ```python
  '''
  .my-class {
      padding: 58px 0 0;
  }
  '''

  Css[
      '.my-class': dict(
          padding=(px/58, 0, 0)
      )
  ]



  Css[
      '.my-class': dict(
          padding='58px 0 0'
      )
  ]
  ```

  <a name="render" />



  Once you are done defining your CSS and HTML, you can render them into string using the `render()` method.

  ```python
  >>> page = html[
      head[
          style[
              Css[
                  '.item': dict(font_size=px/14)
              ]
          ]
      ],
      body[
          div('#my-item.item')['My content.']
      ]
  ]
  >>> print(page.render())
  '<html>
    <head>
      <style>
        .item {
          font-size: 14px;
        }
      </style>
    </head>
    <body>
      <div id="my-item" class="item">
        My content.
      </div>
    </body>
  </html>'
  ```

  By default, `render()` will add indentations with 2 spaces. You can modify this using the `indent` keyword argument.

  ```python
  >>> print(page.render(indent=4))
  '<html>
      <head>
          <style>
              .item {
                  font-size: 14px;
              }
          </style>
      </head>
      <body>
          <div id="my-item" class="item">
              My content.
          </div>
      </body>
  </html>'
  >>> print(page.render(indent=0))  ## render flat string
  '<html><head><style>.item {font-size: 14px;}</style></head><body><div id="my-item" class="item">My content.</div></body></html>'
  ```

  CSS objects can also be rendered the same way.

  ```python
  >>> css = Css[
      'h1': dict(font_size=px/14),
      '.my-class': dict(
          color='blue',
          padding=(0,0,px/20)
      )
  ]
  >>> print(css.render())
  'h1 {
      font-size: 14px;
  }

  .my-class {
      color: blue;
      padding: 0 0 20px;
  }'
  ```

  <a name="building-a-template" />



  There are different ways you can construct a HTML template with `chope`, two of which are *Factory Function* and *Variable Object*.

  <a name="factory-function" />



  Factory function is probably the simplest way to build reusable templates.

  ```python
  def my_list(title: str, items: List[str], ordered: bool = False) -> div:
      list_tag = ol if ordered else ul
      return div[
          f'{title}<br>',
          list_tag[
              [li[i] for i in items]
          ]
      ]

  def my_content(items: List[Component], attrs: dict) -> div:
      return div(**attrs)[
          items
      ]

  result = my_content(
      [
          my_list('Grocery', ['Soap', 'Shampoo', 'Carrots']),
          my_list(
              'Egg Cooking',
              ['Crack egg.', 'Fry egg.', 'Eat egg.'],
              ordered=True
          )
      ],
      {
          'id': 'my-content',
          'class': 'list styled-list'
      }
  )
  ```

  Factory function is a simple, elegant solution to construct a group of small, independent reusable templates. However, when your templates group grows in size and complexity, the factory functions can get unwieldy, as we will see at the end of the next section.

  <a name="variable-object" />



  Another way to build a HTML template is to use the *Variable Object*, `Var`.


  ```python
  from chope import *
  from chope.variable import Var


  template = html[
      div[Var('my-content')]
  ]



  final_html = template.set_vars({'my-content': 'This is my content.'})  ## dict style



  final_html = template.set_vars(my_content='This is my content.')  ## key-value style

  print(final_html.render(indent=0))  ## <html><div>This is my content.</div></html>
  ```

  You can combine both _dict_ and _key-value_ style when setting variable values, but note that **values defined using _kwargs_ take priority over those defined using _dict_**.

  A variable object can have a default value.

  ```python
  >>> print(div[Var('content', 'This is default content.')].render(indent=0))
  '<div>This is default content.</div>'
  ```

  A variable object's value can be set to an element.

  ```python
  >>> content = div[Var('inner')]
  >>> new_content = content.set_vars(inner=div['This is inner content.'])
  >>> print(new_content.render())
  '<div>
    <div>
      This is inner content.
    </div>
  </div>'
  ```

  `Var` works in an element attribute as well.

  ```python
  >>> content = div(name=Var('name'))['My content.']
  >>> new_content = content.set_vars(name='my-content')
  >>> print(new_content.render())
  '<div name="my-content">
    My content.
  </div>'
  ```

  You can use `Var` in CSS too.

  ```python
  >>> css = Css[
      
      'h1': dict(font_size=Var('h1.font-size')),

      
      '.my-class': Var('my-class')
  ]
  >>> new_css = css.set_vars({'h1.font-size': px/1, 'my-class': {'color': 'blue'}})
  >>> print(new_css.render())
  'h1 {
    font-size: 1px;
  }

  .my-class {
    color: blue;
  }'
  ```

  The `set` of all variable names in an element/CSS can be retrieved using the `get_vars()` method.

  ```python
  >>> template = html[
      style[
          Css[
              'h1': dict(font_size=Var('css.h1.font-size'))
          ]
      ],
      div[
          Var('main-content'),
          div[
              Var('inner-content')
          ]
      ]
  ]
  >>> print(template.get_vars())
  {'main-content', 'inner-content', 'css.h1.font-size'}
  ```

  An advantage of using variable object is that it allows for easy deferment of variable value settings, which makes combining templates simple.

  ```python
  navs_template = ul('.nav')[
      Var('navs.items')
  ]

  pagination_template = nav[
      ul('.pagination')[
          li('.page-item', class_=Var(
              'pagination.previous.disabled',
              'disabled'
          ))['Previous'],
          Var('nav.pages'),
          li('.page-item', class_=Var(
              'pagination.next.disabled',
              'disabled'
          ))['Next']
      ]
  ]

  body_template = body[
      navs_template,
      div('.main-content')[Var('body.main-content')],
      pagination_template
  ]
  ```

  Compare that to the equivalent factory function implementation.

  ```python
  def navs_template(items: List[li]) -> ul:
      return ul('.nav')[
          items
      ]

  def pagination_template(
      pages: List[li],
      previous_disabled: bool = True,
      next_disabled: bool = True
  ) -> nav:
      return nav[
          ul('.pagination')[
              li(f'.page-item{" disabled" if previous_disabled else ""}')['Previous'],
              pages,
              li(f'.page-item{" disabled" if next_disabled else ""}')['Next']
          ]
      ]

  def body_template(
      navs_items: List[li],
      pagination_pages: List[li],
      body_main_content: Element,
      pagination_previous_disabled: bool = True,
      pagination_next_disabled: bool = True
  ) -> body:
      return body[
          navs_template(navs_items),
          body_main_content,
          pagination_template(
              pagination_pages,
              pagination_previous_disabled,
              pagination_next_disabled
          )
      ]
  ```

  As you may have observed, the number of parameters for upstream template's factory function can easily explode when you start combining more downstream templates.


pkgId: d35485c6dbda6acf37f30598b78345a9118688b2468eababcb29edb17167e7b0
name: python-choppera
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Chopper inverse velocity transport
url: https://pypi.org/project/choppera/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choppera-0.1.5-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)
  - [Development](#development)

  ```console
  pip install choppera
  ```

  `choppera` is distributed under the terms of the [BSD-3-Clause](https://spdx.org/licenses/BSD-3-Clause.html) license.

  Building `choppera` is achieved through [hatch](https://hatch.pypa.io/)/`hatchling`.
  Testing on supported Python versions can be run via
  ```console
  hatch run test:pytest
  ```


pkgId: 5d7b69ed15271887352d12e5000bb5327adeea6679924ad73563b1400e6074b3
name: python-chord
arch: src
version: 6.0.1
epoch: 0
release: 1
summary: Engaging visualisations, made easy.
url: https://plotapi.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chord-6.0.1-1.src.rpm
checksum_type: sha256
description:
  <a href="https://plotpanel.com"><img src="https://plotpanel.com/static/marketing/plotpanel_preview_1.jpg" alt="PlotPanel"></a>
  > [plotapi.com](https://plotapi.com) &nbsp;&middot;&nbsp;
  > GitHub [@shahinrostami](https://github.com/shahinrostami) &nbsp;&middot;&nbsp;
  > Twitter [@shahinrostami](https://twitter.com/shahinrostami)  &nbsp;&middot;&nbsp;
  > A [Polyra](https://polyra.com) innovation


pkgId: 8f24594f11bb66f4f3494b30358764857529a75f049af48c388702069c591141
name: python-chorde
arch: src
version: 1.0.11
epoch: 0
release: 1
summary: Clustered Caching Library
url: https://github.com/klaussfreire/chorde
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chorde-1.0.11-1.src.rpm
checksum_type: sha256
description:
  * numpy *(for optimizations in FilesCacheClient)*
  * python-memcached *(for MemcachedClient)*
  * pyzmq *(for coherence support)*
  * dnspython  *(for dynamic dns-based load-balancing of MemcachedClient)*
  * cython *(for optimizations in InprocCacheClient)*


pkgId: ff560d6e9e42a03c567c5ebd34fc24a012fcc09217a4b8c0acd714acfaa9a98e
name: python-choreographer
arch: src
version: 0.99.6
epoch: 0
release: 1
summary: Devtools Protocol implementation for chrome.
url: https://pypi.org/project/choreographer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-choreographer-0.99.6-1.src.rpm
checksum_type: sha256
description:
  choreographer allows remote control of browsers from Python.
  It was created to support image generation from browser-based charting tools,
  but can be used for other purposes as well.



  [Kaleido][kaleido] is a cross-platform library for generating static images of plots.
  The original implementation included a custom build of Chrome,
  which has proven very difficult to maintain.
  In contrast,
  this package uses the Chrome binary on the user's machine
  in the same way as testing tools like [Puppeteer][puppeteer];
  the next step is to re-implement Kaleido as a layer on top of it.



  choreographer is a work in progress:
  only Chrome-ish browsers are supported at the moment,
  though we hope to add others.
  (Pull requests are greatly appreciated.)

  Note that we strongly recommend using async/await with this package,
  but it is not absolutely required.
  The synchronous functions in this package are intended as building blocks
  for other asynchronous strategies that Python may favor over async/await in the future.





  - Verbose: `pytest -W error -n auto -vvv -rA --capture=tee-sys tests/test_process.py`
  - Quiet:`pytest -W error -n auto -v -rFe --capture=fd tests/test_process.py`



  - Verbose: `pytest --debug -n auto -W error -vvv -rA --capture=tee-sys --ignore=tests/test_process.py`
  - Quiet :`pytest -W error -n auto -v -rFe --capture=fd --ignore=tests/test_process.py`

  You can also add "--no-headless" to these if you want to see the browser pop up.



  -   Put async and sync tests in different files. Add `_sync.py` to synchronous tests.
  -   If doing process tests, maybe use the same decorators and fixtures in the `test_process.py` file.
  -   If doing browser interaction tests, use `test_placeholder.py` as the minimum template.



  We need your help to test this package on different platforms
  and for different use cases.
  To get started:

  1.  Clone this repository.
  1.  Create and activate a Python virtual environment.
  1.  Install this repository using `pip install .` or the equivalent.
  1.  Run `dtdoctor` and paste the output into an issue in this repository.



  Save the following code to `example.py` and run with Python.

  ```
  import asyncio
  import choreographer as choreo


  async def example():
      browser = await choreo.Browser(headless=False)
      tab = await browser.create_tab("https://google.com")
      await asyncio.sleep(3)
      await tab.send_command("Page.navigate", params={"url": "https://github.com"})
      await asyncio.sleep(3)


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

  Step by step, this example:

  1.  Imports the required libraries.
  1.  Defines an `async` function
      (because `await` can only be used inside `async` functions).
  1.  Asks choreographer to create a browser.
      `headless=False` tells it to display the browser on the screen;
      the default is no display.
  1.  Wait three seconds for the browser to be created.
  1.  Create another tab.
      (Note that users can't rearrange programmatically-generated tabs using the mouse,
      but that's OK: we're not trying to replace testing tools like [Puppeteer][puppeteer].)
  1.  Sleep again.
  1.  Runs the example function.

  See [the devtools reference][devtools-ref] for a list of possible commands.



  Try adding the following to the example shown above:

  ```python
      
      async def dump_event(response):
          print(str(response))


      
      async def error_event(response):
          raise Exception(str(response))


      browser.subscribe("Target.targetCrashed", error_event)
      new_tab.subscribe("Page.loadEventFired", dump_event)
      browser.subscribe("Target.*", dump_event) # dumps all "Target" events
      response = await new_tab.subscribe_once("Page.lifecycleEvent")
      
      browser.unsubscribe("Target.*")
      
      
      
      
  ```



  You can use this library without `asyncio`,

  ```
  my_browser = choreo.Browser() # blocking until open
  ```

  However,
  you are responsible for calling `browser.pipe.read_jsons(blocking=True|False)` when necessary
  and organizing the results.
  `browser.run_output_thread()` will start a second thread that constantly prints all responses from the browser,
  but it can't be used with `asyncio` and won't play nice with any other read.
  In other words,
  unles you're really, really sure you know what you're doing,
  use `asyncio`.



  We provide a `Browser` and `Tab` interface,
  but there is also a lower-level `Target` and `Session` interface that one can use if needed.
  We will document these as the API stabilizes.

  [devtools-ref]: https://chromedevtools.github.io/devtools-protocol/
  [kaleido]: https://pypi.org/project/kaleido/
  [puppeteer]: https://pptr.dev/


pkgId: 0f7d9263b61e5b8cdfe139c3d2dda23b8e7f696eabefffbf46235dac23d0e6ee
name: python-chosco
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: Package on top of ipywidgets to label media resources on Notebook pages.
url: https://github.com/alice-biometrics/chosco
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chosco-0.3.6-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/alice-biometrics/custom-emojis/blob/master/images/alice_header.png" width=auto>

  Package on top of `ipywidgets` to label media resources on `Notebook` pages.



  - [Installation :computer:](#installation-computer)
  - [Development :construction_worker:](#development-construction_worker)
  - [Testing :white_check_mark:](#testing-white_check_mark)
  - [Contact :mailbox_with_mail:](#contact-mailbox_with_mail)




  ```console
  >> pip install chosco
  ```



  Use [lume :fire:](https://github.com/alice-biometrics/lume) to install dependencies:

  Example:

  ```console
  >> python3 -m venv venv
  >> source venv/bin/activate
  (venv) >> pip install lume
  (venv) >> lume -install
  ```





  ```console
  (venv) >> lume -test
  ```



  Run jupyter server:

  ```console
  (venv) >> jupyter notebook
  ```

  Go to dummy example [here](http://localhost:8888/notebooks/notebooks/dummy_annotation.ipynb)



  support@alicebiometrics.com


pkgId: e8686ddc579a76005238baeb7939eff09ac387f6183d9fc6980011444cad828e
name: python-chowtest-polars
arch: src
version: 0.0.1a3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/chowtest-polars/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chowtest-polars-0.0.1a3-1.src.rpm
checksum_type: sha256
rpm_license:
  # License  This project is a fork of the original project by David Woroniuk.  ## Original License  MIT License  Copyright (c) 2020 David Woroniuk  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.  ## Modifications This fork was created by Henkhogan on 2024-08-27. The modifications made to the original project are licensed under the same terms as the original license.


pkgId: bdcd8efbcf5dd58fe83a7afc77c9383d3784eb9ebb4100840559b9f1e4306ba9
name: python-chris-plugin
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: ChRIS plugin helper
url: https://github.com/FNNDSC/chris_plugin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chris-plugin-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/FNNDSC/chris_plugin/branch/master/graph/badge.svg?token=TG3CEHU2H4)](https://codecov.io/gh/FNNDSC/chris_plugin)
  [![.github/workflows/test.yml](https://github.com/FNNDSC/chris_plugin/actions/workflows/test.yml/badge.svg)](https://github.com/FNNDSC/chris_plugin/actions/workflows/test.yml)
  [![PyPI](https://img.shields.io/pypi/v/chris_plugin)](https://pypi.org/project/chris_plugin/)
  [![License - MIT](https://img.shields.io/pypi/l/chris_plugin)](https://github.com/FNNDSC/chris_plugin/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  _ChRIS_ is a platform for scientific and medical applications.
  https://chrisproject.org/

  This repository provides `chris_plugin`, a Python utility library
  for writing programs in Python which can run on _ChRIS_.



  Have an existing Python program? See
  [HOW TO: Convert an existing Python app](https://github.com/FNNDSC/chris_plugin/wiki/HOW-TO:-Convert-an-existing-Python-app)
  into a _ChRIS_ _ds_ plugin.

  If you're creating a **new** program,
  you can start from this template:
  https://github.com/FNNDSC/python-chrisapp-template

  Examples can be found in [./examples](./examples).



  After developing a plugin, use the command `chris_plugin_info`
  to produce a JSON description of your *ChRIS* plugin.

  ```shell
  chris_plugin_info --dock-image {registry}/{repo}/{name}:{version} [module_name]
  ```

  If `module_name` is not given, then `chris_plugin_info`
  will automatically discover your *ChRIS* plugin.



  `chris_plugin` strives to have zero-dependencies and compatible with Python 3.8 through 3.12.


pkgId: bd8b0599df13605b4cf7adf2d3ba80a4f42efb84bdecdab9ab5b961192c0de12
name: python-chrisapp
arch: src
version: 2.5.3
epoch: 0
release: 1
summary: Superclass for Chris plugin apps
url: https://github.com/FNNDSC/chrisapp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrisapp-2.5.3-1.src.rpm
checksum_type: sha256
description:
  chrisapp


  The base module for Chris' plugin apps.

  .. image:: https://badge.fury.io/py/chrisapp.svg
      :target: https://badge.fury.io/py/chrisapp

  .. image:: https://travis-ci.org/FNNDSC/chrisapp.svg?branch=master
      :target: https://travis-ci.org/FNNDSC/chrisapp


pkgId: 143d06b84b836f8780392b5b420909ca14c4f222a57d3e1b35daff656abb2a22
name: python-chrisbase
arch: src
version: 0.5.6
epoch: 0
release: 1
summary: Base library for python coding
url: https://github.com/chrisjihee/chrisbase
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrisbase-0.5.6-1.src.rpm
checksum_type: sha256
description:
  Base library for python coding



  * Install through pip
      ```bash
      pip install chrisbase
      ```

  * Install through git
      ```bash
      rm -rf chrisbase*
      git clone git@github.com:chrisjihee/chrisbase.git
      pip install -U -e chrisbase*
      ```



  - https://pypi.org/project/chrisbase/
  - https://github.com/chrisjihee/chrisbase/


pkgId: ee19f1db1b22bc902a11274d9f46c77da06fec2921f75adee3406f378708f849
name: python-chrisdata
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Data processing tools for data analysis
url: https://github.com/chrisjihee/chrisdata
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrisdata-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Data processing tools for data analysis




  1. Install Miniforge
      ```bash
      wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
      bash Miniforge3-$(uname)-$(uname -m).sh
      ```

  2. Clone the repository
      ```bash
      rm -rf chrisdata*
      git clone git@github.com:chrisjihee/chrisdata.git
      cd chrisdata*
      ```

  3. Create a new environment
      ```bash
      mamba create -n chrisdata python=3.11 -y
      mamba activate chrisdata
      ```

  4. Install the required packages
      ```bash
      pip install -U -e .
      rm -rf chrisbase*; git clone git@github.com:chrisjihee/chrisbase.git
      pip install -U -e chrisbase*
      pip list | grep -E "mongo|search|Wiki|wiki|json|pydantic|chris|Flask"
      ```

  5. Install MongoDB
      ```bash
      mkdir mongodb; cd mongodb; mkdir data log
      if [ "$(uname)" = "Linux" ]; then
        aria2c https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu2204-8.0.0.tgz
      elif [ "$(uname)" = "Darwin" ]; then
        aria2c https://fastdl.mongodb.org/osx/mongodb-macos-arm64-8.0.0.tgz
      fi
      tar zxvf mongodb-*.tgz --strip-components=1
      cd ..
      ```

  6. Run MongoDB
      ```bash
      cd mongodb
      bin/mongod --config ../cfg/mongod-8800.yaml
      cd ..
      ```
      ```bash
      cd mongodb
      bin/mongod --config ../cfg/mongod-8801.yaml
      cd ..
      ```

  7. Install Elasticsearch
      ```bash
      mkdir elasticsearch7; cd elasticsearch7
      if [ "$(uname)" = "Linux" ]; then
        aria2c https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.17.10-linux-x86_64.tar.gz
      elif [ "$(uname)" = "Darwin" ]; then
        aria2c https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.17.10-darwin-aarch64.tar.gz
      fi
      tar zxf elasticsearch-*.tar.gz --strip-components 1
      sed -i '' 's/#http.port: 9200/http.port: 9717/g' ./config/elasticsearch.yml
      echo "xpack.security.enabled: true" >> ./config/elasticsearch.yml
      cd ..
      ```

  8. Link input data
      ```bash
      cd input
      ln -s /mnt/geo/data/wikidata .
      ln -s /mnt/geo/data/wikipedia .
      cd ..
      ```




  1. Show help
      ```bash
      python -m chrisdata.cli --help
      ```

      ```bash
      python -m chrisdata.cli wikipedia --help
      ```

      ```bash
      python -m chrisdata.cli wikidata --help
      ```

  2. Run command
    * To convert Wikipedia articles
      ```bash
      python -m chrisdata.cli wikipedia convert
      ```

    * To parse Wikidata dump
      ```bash
      python -m chrisdata.cli wikidata parse
      ```

    * To filter Wikidata entities
      ```bash
      python -m chrisdata.cli wikidata filter
      ```

    * To convert Wikidata entities
      ```bash
      python -m chrisdata.cli wikidata convert
      ```




  * https://github.com/chrisjihee/chrisdata/
  * https://github.com/chrisjihee/chrisbase/


pkgId: f11d9bcdf7de9eaddae2c3b155b527400925eadc09bff45984d88d0330b34616
name: python-chrislab
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: An advanced tool for doing experimental study.
url: https://github.com/chrisjihee/chrislab
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrislab-0.7.1-1.src.rpm
checksum_type: sha256
description:
  An advanced tool for doing experimental study



  ```bash
  pip install chrislab
  ```

  ```bash
  git clone https://github.com/chrisjihee/chrislab
  cd chrislab
  pip install .
  ```



  - https://pypi.org/project/chrislab/
  - https://github.com/chrisjihee/chrislab/


pkgId: 355c799160ac9732dc61eb1917e348be38c733be25b0cebb31c6138aef97acc0
name: python-chroma-feedback
arch: src
version: 13.4.0
epoch: 0
release: 1
url: https://chroma-feedback.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chroma-feedback-13.4.0-1.src.rpm
checksum_type: sha256
summary:
  Turn your RGB powered hardware into a status indicator for continuous integration, continuous deployment and infrastructure monitoring

description:
  > Turn your RGB powered hardware into a status indicator for continuous integration, continuous deployment and infrastructure monitoring.
  [![Build Status](https://img.shields.io/github/actions/workflow/status/henryruhs/chroma-feedback/ci.yml.svg?branch=master)](https://github.com/henryruhs/chroma-feedback/actions?query=workflow:ci)
  [![Coverage Status](https://img.shields.io/coveralls/henryruhs/chroma-feedback.svg)](https://coveralls.io/r/henryruhs/chroma-feedback)
  [![PyPI](https://img.shields.io/pypi/v/chroma-feedback.svg)](https://pypi.org/project/chroma-feedback)
  [![License](https://img.shields.io/pypi/l/chroma-feedback.svg)](https://pypi.org/project/chroma-feedback)


pkgId: 0402900d01567a974734e1c6ad0a927e946b0278057e8d3aa559b21c84609869
name: python-chroma-haystack
arch: src
version: 0.22.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/chroma-haystack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chroma-haystack-0.22.1-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Chroma Document Store for Haystack](#chroma-document-store-for-haystack)
    - [Installation](#installation)
    - [Examples](#examples)
    - [License](#license)

  ```console
  pip install chroma-haystack
  ```

  You can find a code example showing how to use the Document Store and the Retriever under the `example/` folder of this repo or in [this Colab](https://colab.research.google.com/drive/1YpDetI8BRbObPDEVdfqUcwhEX9UUXP-m?usp=sharing).

  `chroma-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.


pkgId: 7e24892eccbae7475930275616a65309392e3d8b29e28de3a701063f44a16540
name: python-chromaconsole
arch: src
version: 0.8.6.3
epoch: 0
release: 1
summary: A small colorful module to change text colors in terminal
url: https://github.com/umittadelen/chromaconsole
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromaconsole-0.8.6.3-1.src.rpm
checksum_type: sha256
description:
  Chroma console is a python package for adding color and style to terminal text output using ANSI escape codes.

  * if ***requests*** is installed this package updates automaticaly
  * some terminals still don't support *ANSI escape*

  <br>



  ```shell
  pip install chromaconsole
  ```

  <br>


  This package works using ***[ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code)***

  <br>


  <details>
  <summary>Click here to see all functions</summary>

  ```python

  Styling.disable()
  Styling.enable()
  Style.reset()
  Style.bold()
  Style.faint()
  Style.italic()
  Style.underlined()
  Style.slow_blink()
  Style.rapid_blink()
  Style.reverse()
  Style.hidden()
  Style.strikethrough()
  Style.doubly_underlined()
  Style.normal_intensity()
  Style.not_italic()
  Style.not_underlined()
  Style.not_blinking()
  Style.proportional_spacing()
  Style.not_reversed()
  Style.reveal()
  Style.not_strikethrough()
  Style.not_proportional_spacing()
  Style.overlined()
  Style.not_overlined()
  Style.minecraft(*args)


  Color.text(*args)
  Color.text_gradient("text", color, color)
  Color.default_text()
  Color.background(*args)
  Color.background_gradient("text", color, color)
  Color.default_background()
  Color.Text.black()
  Color.Text.red()
  Color.Text.green()
  Color.Text.yellow()
  Color.Text.blue()
  Color.Text.magenta()
  Color.Text.cyan()
  Color.Text.white()
  Color.Text.br_black()
  Color.Text.br_red()
  Color.Text.br_green()
  Color.Text.br_yellow()
  Color.Text.br_blue()
  Color.Text.br_magenta()
  Color.Text.br_cyan()
  Color.Text.br_white()
  Color.Background.black()
  Color.Background.red()
  Color.Background.green()
  Color.Background.yellow()
  Color.Background.blue()
  Color.Background.magenta()
  Color.Background.cyan()
  Color.Background.white()
  Color.Background.br_black()
  Color.Background.br_red()
  Color.Background.br_green()
  Color.Background.br_yellow()
  Color.Background.br_blue()
  Color.Background.br_magenta()
  Color.Background.br_cyan()
  Color.Background.br_white()


  Console.clr_scr_to_end()
  Console.clr_scr_to_begin()
  Console.clr_entire_scr()
  Console.clr_line_to_end()
  Console.clr_line_to_begin()
  Console.clr_entire_line()
  Console.scroll_up(int)
  Console.scroll_down(int)
  Console.bell()
  Console.save_cursor()
  Console.restore_cursor()
  Console.switch_alt_scr()
  Console.switch_orig_scr()
  Console.show_cursor()
  Console.hide_cursor()
  ```
  </details>

  <br>



  ```python
  from chromaconsole import *

  print(f"{Color.Text.red()}here is red colored text{Style.reset()}")
  print(f"{Color.text(r, g, b)}here is RGB colored text{Style.reset()}")
  print(f"{Color.background(r, g, b)}here is RGB colored background{Style.reset()}")

  print(f"{Color.text('#rrggbb')}here is HEX colored text{Style.reset()}")
  print(f"{Color.background('#rrggbb')}here is HEX colored background{Style.reset()}")

  print(f"{Style.bold()}Bold {Style.reset()}")
  print(f"{Style.italic()}Italic {Style.reset()}")
  print(f"{Style.underlined()}Underlined {Style.reset()}")
  print(f"{Style.strikethrough()}Strikethrough {Style.reset()}")

  print(f"{Style.bold()}{Style.italic()}bold+italic {Style.reset()}")
  print(f"{Style.minecraft('§','§ahello §4world§r')}")
  ```

  <br>



  After executing the `Styling.disable()` command, the system will no longer apply coloring and styling to the content. To re-enable these features, simply use the `Styling.enable()` command.

  ```python
  from chromaconsole import Styling

  Styling.disable()
  print(f"{Color.text(r, g, b)}text without color and style{Style.reset()}")
  Styling.enable()
  print(f"{Color.text(r, g, b)}text with color and style{Style.reset()}")
  ```


pkgId: a952f0b2a0b002e7cebca483d66a7395e292af20035f3b765dca35be5fbf9bf1
name: python-chromadb
arch: src
version: 0.5.12
epoch: 0
release: 1
summary: Chroma.
url: https://github.com/chroma-core/chroma
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromadb-0.5.12-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://trychroma.com"><img src="https://user-images.githubusercontent.com/891664/227103090-6624bf7d-9524-4e05-9d2c-c28d5d451481.png" alt="Chroma logo"></a>
  </p>

  <p align="center">
      <b>Chroma - the open-source embedding database</b>. <br />
      The fastest way to build Python or JavaScript LLM apps with memory!
  </p>

  <p align="center">
    <a href="https://discord.gg/MMeYNTmh3x" target="_blank">
        <img src="https://img.shields.io/discord/1073293645303795742?cacheSeconds=3600" alt="Discord">
    </a> |
    <a href="https://github.com/chroma-core/chroma/blob/master/LICENSE" target="_blank">
        <img src="https://img.shields.io/static/v1?label=license&message=Apache 2.0&color=white" alt="License">
    </a> |
    <a href="https://docs.trychroma.com/" target="_blank">
        Docs
    </a> |
    <a href="https://www.trychroma.com/" target="_blank">
        Homepage
    </a>
  </p>


  ```bash
  pip install chromadb # python client


  ```

  The core API is only 4 functions (run our [💡 Google Colab](https://colab.research.google.com/drive/1QEzFyqnoFxq7LUGyP1vzR4iLt9PpCDXv?usp=sharing) or [Replit template](https://replit.com/@swyx/BasicChromaStarter?v=1)):

  ```python
  import chromadb

  client = chromadb.Client()


  collection = client.create_collection("all-my-documents")


  collection.add(
      documents=["This is document1", "This is document2"], # we handle tokenization, embedding, and indexing automatically. You can skip that and add your own embeddings as well
      metadatas=[{"source": "notion"}, {"source": "google-docs"}], # filter on these!
      ids=["doc1", "doc2"], # unique for each doc
  )


  results = collection.query(
      query_texts=["This is a query document"],
      n_results=2,
      
      
  )
  ```


  - __Simple__: Fully-typed, fully-tested, fully-documented == happiness
  - __Integrations__: [`🦜️🔗 LangChain`](https://blog.langchain.dev/langchain-chroma/) (python and js), [`🦙 LlamaIndex`](https://twitter.com/atroyn/status/1628557389762007040) and more soon
  - __Dev, Test, Prod__: the same API that runs in your python notebook, scales to your cluster
  - __Feature-rich__: Queries, filtering, density estimation and more
  - __Free & Open Source__: Apache 2.0 Licensed



  For example, the `"Chat your data"` use case:
  1. Add documents to your database. You can pass in your own embeddings, embedding function, or let Chroma embed them for you.
  2. Query relevant documents with natural language.
  3. Compose documents into the context window of an LLM like `GPT3` for additional summarization or analysis.



  What are embeddings?

  - [Read the guide from OpenAI](https://platform.openai.com/docs/guides/embeddings/what-are-embeddings)
  - __Literal__: Embedding something turns it from image/text/audio into a list of numbers. 🖼️ or 📄 => `[1.2, 2.1, ....]`. This process makes documents "understandable" to a machine learning model.
  - __By analogy__: An embedding represents the essence of a document. This enables documents and queries with the same essence to be "near" each other and therefore easy to find.
  - __Technical__: An embedding is the latent-space position of a document at a layer of a deep neural network. For models trained specifically to embed data, this is the last layer.
  - __A small example__: If you search your photos for "famous bridge in San Francisco". By embedding this query and comparing it to the embeddings of your photos and their metadata - it should return photos of the Golden Gate Bridge.

  Embeddings databases (also known as **vector databases**) store embeddings and allow you to search by nearest neighbors rather than by substrings like a traditional database. By default, Chroma uses [Sentence Transformers](https://docs.trychroma.com/guides/embeddings#default:-all-minilm-l6-v2) to embed for you but you can also use OpenAI embeddings, Cohere (multilingual) embeddings, or your own.



  Chroma is a rapidly developing project. We welcome PR contributors and ideas for how to improve the project.
  - [Join the conversation on Discord](https://discord.gg/MMeYNTmh3x) - `#contributing` channel
  - [Review the 🛣️ Roadmap and contribute your ideas](https://docs.trychroma.com/roadmap)
  - [Grab an issue and open a PR](https://github.com/chroma-core/chroma/issues) - [`Good first issue tag`](https://github.com/chroma-core/chroma/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
  - [Read our contributing guide](https://docs.trychroma.com/contributing)

  **Release Cadence**
  We currently release new tagged versions of the `pypi` and `npm` packages on Mondays. Hotfixes go out at any time during the week.



  [Apache 2.0](./LICENSE)


pkgId: dbd25eb877c8b6e60c4dadab126c2a7cc59af8d1f8f7e7a58cf2a91ae919a789
name: python-chromadb-client
arch: src
version: 0.5.15
epoch: 0
release: 1
summary: Chroma Client.
url: https://github.com/chroma-core/chroma
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromadb-client-0.5.15-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://trychroma.com"><img src="https://user-images.githubusercontent.com/891664/227103090-6624bf7d-9524-4e05-9d2c-c28d5d451481.png" alt="Chroma logo"></a>
  </p>

  <p align="center">
      <b>Chroma - the open-source embedding database</b>. <br />
      This package is for the the Python HTTP client-only library for Chroma. This client connects to the Chroma Server. If that it not what you are looking for, you might want to check out the <a href="https://github.com/chroma-core/chroma ">full library</a>.
  </p>


  ```bash
  pip install chromadb-client # python http-client only library
  ```

  To connect to your server and perform operations using the client only library, you can do the following:

  ```python
  import chromadb

  client = chromadb.HttpClient(host="localhost", port=8000)

  collection = client.create_collection("all-my-documents")

  collection.add(
      documents=["This is document1", "This is document2"],
      metadatas=[{"source": "notion"}, {"source": "google-docs"}], # filter on these!
      ids=["doc1", "doc2"], # unique for each doc
      embeddings = [[1.2, 2.1, ...], [1.2, 2.1, ...]]
  )

  results = collection.query(
      query_texts=["This is a query document"],
      n_results=2,
      
      
  )
  ```


  [Apache 2.0](./LICENSE)


pkgId: aabeaf6347a361155eebae4f73c2482f8778bcff06ef65b01fd6cb4f58f2aca6
name: python-chromadb-ops
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Tiny unofficial ChromaDB operations CLI to help you manage your ChromaDB instance.
url: https://github.com/amikos-tech/chromadb-ops/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromadb-ops-0.0.10-1.src.rpm
checksum_type: sha256
description:
  Tiny collection of utilities to help you managed ChromaDB indices.

  WARNING: These tools rely on internal ChromaDB APIs and may break in the future.



  Before you use these tools make sure your ChromaDB persistent dir, on which you intend to run these tools, is backed up.



  ```bash
  pip install chromadb-ops
  ```





  Gather general information about your persistent Chroma instance. This command is useful to understand what's going on
  internally in Chroma and to get recommendations or support from the team by providing the output.

  ```bash
  chops info /path/to/persist_dir
  ```

  Supported options are:

  - `--skip-collection-names` (`-s`) - to skip specific collections
  - `--privacy-mode` (`-p`) - privacy mode hides paths and collection names so that the output can be shared without
    exposing sensitive information

  When sharing larger outputs consider storing the output in a file:

  ```bash
  chops info /path/to/persist_dir -p > chroma_info.txt
  ```

  Sample output:

  ```console
                                   General Info
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                    Property ┃ Value                                          ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │              Chroma Version │ 0.5.5                                          │
  │        Number of Collection │ 1                                              │
  │           Persist Directory │ /tmp/tmp9l3ceuvp                               │
  │      Persist Directory Size │ 142.2MiB                                       │
  │              SystemDB size: │ 81.6MiB (/tmp/tmp9l3ceuvp/chroma.sqlite3)      │
  │     Orphan HNSW Directories │ []                                             │
  └─────────────────────────────┴────────────────────────────────────────────────┘
  ───────────────────────────────── Collections ──────────────────────────────────
  ───────────────────────────────────── test ─────────────────────────────────────
                               'test' Collection Data
  ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃         Table Data ┃ Value                                                   ┃
  ┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │                 ID │ 9e80e4fd-fd4b-47b8-810c-e8ffa57c1912                    │
  │               Name │ test                                                    │
  │           Metadata │ None                                                    │
  │          Dimension │ 1536                                                    │
  │             Tenant │ default_tenant                                          │
  │           Database │ default_database                                        │
  │            Records │ 10,000                                                  │
  │        WAL Entries │ 10,000                                                  │
  └────────────────────┴─────────────────────────────────────────────────────────┘
  ─────────────────────────────────── Segments ───────────────────────────────────
                              Metadata Segment (test)
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                Property ┃ Value                                              ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │              Segment ID │ 832fa2cd-6c40-4eee-ad7d-35f260acaaaa               │
  │                    Type │ urn:chroma:segment/metadata/sqlite                 │
  │                   Scope │ METADATA                                           │
  │        SysDB Max Seq ID │ 10,000                                             │
  └─────────────────────────┴────────────────────────────────────────────────────┘
                                HNSW Segment (test)
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                     Property ┃ Value                                         ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │                   Segment ID │ 13609103-d317-4556-a744-008c96229b72          │
  │                         Type │ urn:chroma:segment/vector/hnsw-local-persist… │
  │                        Scope │ VECTOR                                        │
  │                         Path │ /tmp/tmp9l3ceuvp/13609103-d317-4556-a744-008… │
  │             SysDB Max Seq ID │ 0                                             │
  │                HNSW Dir Size │ 60.6MiB                                       │
  │     HNSW Metadata Max Seq ID │ 10,000                                        │
  │   HNSW Metadata Total Labels │ 10,000                                        │
  │                      WAL Gap │ 0                                             │
  │ HNSW Raw Total Active Labels │ 10,000                                        │
  │    HNSW Raw Allocated Labels │ 10,000                                        │
  │           HNSW Orphan Labels │ set()                                         │
  │          Fragmentation Level │ 0.0                                           │
  └──────────────────────────────┴───────────────────────────────────────────────┘
  ```

  ⚠️ Interesting things to look for:

  - Fragmentation Level - the higher the value the more unnecessary memory and performance hits your HNSW index suffers.
    It needs to be rebuilt.
  - Orphan HNSW Directories - these are directories that are not associated with any collection. They can be safely
    deleted.
  - WAL Entries - high values usually means that you need prune your WAL. Use either this tool or
    the [official Chroma CLI](https://cookbook.chromadb.dev/core/advanced/wal-pruning/#chroma-cli).
  - HNSW Orphan Labels - this must always be empty set, if you see anything else report it
    in [Discord](https://discord.gg/MMeYNTmh3x).



  **General Info**

  This section presents general Chroma persistent dir info.

  - Chroma Version - the currently installed Chroma version.
  - Number of Collection - the number of collections in the persistent dir.
  - Persist Directory - the path to the persistent dir (if privacy mode is off).
  - Persist Directory Size - the size of the persistent dir.
  - SystemDB size - the size of the system database (if privacy mode is off the full path to the sqlite3 file is shown).
  - Orphan HNSW Directories - a list of orphan HNSW directories. These directories are present in the persistent dir but
    are not associated with any collection.

  **Collections**

  - ID - the collection ID.
  - Name - the collection name.
  - Metadata - the metadata associated with the collection.
  - Dimension - the dimension of the embeddings in the collection. (this can be None in case no vectors are present and
    the collection is newly created).
  - Tenant - the tenant of the collection.
  - Database - the database of the collection.
  - Records - the number of records in the collection.
  - WAL Entries - the number of WAL entries in the collection (as of 0.5.5 for new instances Chroma will clean WAL for
    each collection periodically).

  **Metadata Segment**

  - Segment ID - the segment ID.
  - Type - the segment type.
  - Scope - the segment scope.
  - SysDB Max Seq ID - the maximum sequence ID in the system database.

  **HNSW Segment**

  - Segment ID - the segment ID.
  - Type - the segment type.
  - Scope - the segment scope.
  - Path - the path to the HNSW directory.
  - SysDB Max Seq ID - the maximum sequence ID in the system database.
  - HNSW Dir Size - the size of the HNSW directory.
  - HNSW Metadata Max Seq ID - the maximum sequence ID in the HNSW metadata.
  - HNSW Metadata Total Labels - the total number of labels in the HNSW metadata.
  - WAL Gap - the difference between the maximum sequence ID in the system database and the maximum sequence ID in the
    HNSW
    metadata. The gap usually represents the number of WAL entries that are not committed to the HNSW index.
  - HNSW Raw Total Active Labels - the total number of active labels in the HNSW index.
  - HNSW Raw Allocated Labels - the total number of allocated labels in the HNSW index.
  - HNSW Orphan Labels - a set of orphan labels in the HNSW index. These are labels in the HNSW index that are not visible
    to Chroma as they are not part of the metadata. This set should always be empty, if not please report it!!!
  - Fragmentation Level - the fragmentation level of the HNSW index.



  This command ensures your WAL is committed to binary vector index (HNSW).

  ```bash
  chops commit-wal /path/to/persist_dir
  ```

  > Note: You can skip certain collections by running `chops commit-wal /path/to/persist_dir --skip <collection_name>`



  This command cleans up the committed portion of the WAL and VACUUMs the database.

  ```bash
  chops clean-wal /path/to/persist_dir
  ```



  This commands exports the WAL to a `jsonl` file. The command can be useful in taking backups of the WAL.

  ```bash
  chops export-wal /path/to/persist_dir --out /path/to/export.jsonl
  ```

  > Note: If --out or -o is not specified the command will print the output to stdout.



  This command rebuilds the full-text search index.

  > Note: **_Why is this needed_**? Users have reported broken FTS indices that result in a error of this
  > kind: `no such table: embedding_fulltext_search`

  ```bash
  chops rebuild-fts /path/to/persist_dir
  ```



  This command cleans up orphaned vector segment directories.

  ```bash
  chops clean /path/to/persist_dir
  ```

  > Note: The command is particularly useful for windows users where deleting collections may leave behind orphaned vector
  > segment directories due to Windows file locking.



  > Note: You have to mount your persist directory into the container for the commands to work.


  Building the image:

  ```bash
  docker build -t chops .
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data ghcr.io/amikos-tech/chromadb-ops/chops:latest commit-wal /chroma-data
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data ghcr.io/amikos-tech/chromadb-ops/chops:latest clean-wal /chroma-data
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data -v ./backup:/backup ghcr.io/amikos-tech/chromadb-ops/chops:latest export-wal /chroma-data --out /backup/export.jsonl
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data ghcr.io/amikos-tech/chromadb-ops/chops:latest rebuild-fts /chroma-data
  ```


pkgId: 6863a615f5c2c9d68f0e4f87be4669fff2706f101adc2bca05ccfd9261ab9436
name: python-chromadb-ops
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: Tiny unofficial ChromaDB operations CLI to help you manage your ChromaDB instance.
url: https://github.com/amikos-tech/chromadb-ops/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromadb-ops-0.0.9-1.src.rpm
checksum_type: sha256
description:
  Tiny collection of utilities to help you managed ChromaDB indices.

  WARNING: These tools rely on internal ChromaDB APIs and may break in the future.



  Before you use these tools make sure your ChromaDB persistent dir, on which you intend to run these tools, is backed up.



  ```bash
  pip install chromadb-ops
  ```





  Gather general information about your persistent Chroma instance. This command is useful to understand what's going on
  internally in Chroma and to get recommendations or support from the team by providing the output.

  ```bash
  chops info /path/to/persist_dir
  ```

  Supported options are:

  - `--skip-collection-names` (`-s`) - to skip specific collections
  - `--privacy-mode` (`-p`) - privacy mode hides paths and collection names so that the output can be shared without
    exposing sensitive information

  When sharing larger outputs consider storing the output in a file:

  ```bash
  chops info /path/to/persist_dir -p > chroma_info.txt
  ```

  Sample output:

  ```console
                                   General Info
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                    Property ┃ Value                                          ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │              Chroma Version │ 0.5.5                                          │
  │        Number of Collection │ 1                                              │
  │           Persist Directory │ /tmp/tmp9l3ceuvp                               │
  │      Persist Directory Size │ 142.2MiB                                       │
  │              SystemDB size: │ 81.6MiB (/tmp/tmp9l3ceuvp/chroma.sqlite3)      │
  │     Orphan HNSW Directories │ []                                             │
  └─────────────────────────────┴────────────────────────────────────────────────┘
  ───────────────────────────────── Collections ──────────────────────────────────
  ───────────────────────────────────── test ─────────────────────────────────────
                               'test' Collection Data
  ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃         Table Data ┃ Value                                                   ┃
  ┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │                 ID │ 9e80e4fd-fd4b-47b8-810c-e8ffa57c1912                    │
  │               Name │ test                                                    │
  │           Metadata │ None                                                    │
  │          Dimension │ 1536                                                    │
  │             Tenant │ default_tenant                                          │
  │           Database │ default_database                                        │
  │            Records │ 10,000                                                  │
  │        WAL Entries │ 10,000                                                  │
  └────────────────────┴─────────────────────────────────────────────────────────┘
  ─────────────────────────────────── Segments ───────────────────────────────────
                              Metadata Segment (test)
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                Property ┃ Value                                              ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │              Segment ID │ 832fa2cd-6c40-4eee-ad7d-35f260acaaaa               │
  │                    Type │ urn:chroma:segment/metadata/sqlite                 │
  │                   Scope │ METADATA                                           │
  │        SysDB Max Seq ID │ 10,000                                             │
  └─────────────────────────┴────────────────────────────────────────────────────┘
                                HNSW Segment (test)
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                     Property ┃ Value                                         ┃
  ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │                   Segment ID │ 13609103-d317-4556-a744-008c96229b72          │
  │                         Type │ urn:chroma:segment/vector/hnsw-local-persist… │
  │                        Scope │ VECTOR                                        │
  │                         Path │ /tmp/tmp9l3ceuvp/13609103-d317-4556-a744-008… │
  │             SysDB Max Seq ID │ 0                                             │
  │                HNSW Dir Size │ 60.6MiB                                       │
  │     HNSW Metadata Max Seq ID │ 10,000                                        │
  │   HNSW Metadata Total Labels │ 10,000                                        │
  │                      WAL Gap │ 0                                             │
  │ HNSW Raw Total Active Labels │ 10,000                                        │
  │    HNSW Raw Allocated Labels │ 10,000                                        │
  │           HNSW Orphan Labels │ set()                                         │
  │          Fragmentation Level │ 0.0                                           │
  └──────────────────────────────┴───────────────────────────────────────────────┘
  ```

  ⚠️ Interesting things to look for:

  - Fragmentation Level - the higher the value the more unnecessary memory and performance hits your HNSW index suffers.
    It needs to be rebuilt.
  - Orphan HNSW Directories - these are directories that are not associated with any collection. They can be safely
    deleted.
  - WAL Entries - high values usually means that you need prune your WAL. Use either this tool or
    the [official Chroma CLI](https://cookbook.chromadb.dev/core/advanced/wal-pruning/#chroma-cli).
  - HNSW Orphan Labels - this must always be empty set, if you see anything else report it
    in [Discord](https://discord.gg/MMeYNTmh3x).



  **General Info**

  This section presents general Chroma persistent dir info.

  - Chroma Version - the currently installed Chroma version.
  - Number of Collection - the number of collections in the persistent dir.
  - Persist Directory - the path to the persistent dir (if privacy mode is off).
  - Persist Directory Size - the size of the persistent dir.
  - SystemDB size - the size of the system database (if privacy mode is off the full path to the sqlite3 file is shown).
  - Orphan HNSW Directories - a list of orphan HNSW directories. These directories are present in the persistent dir but
    are not associated with any collection.

  **Collections**

  - ID - the collection ID.
  - Name - the collection name.
  - Metadata - the metadata associated with the collection.
  - Dimension - the dimension of the embeddings in the collection. (this can be None in case no vectors are present and
    the collection is newly created).
  - Tenant - the tenant of the collection.
  - Database - the database of the collection.
  - Records - the number of records in the collection.
  - WAL Entries - the number of WAL entries in the collection (as of 0.5.5 for new instances Chroma will clean WAL for
    each collection periodically).

  **Metadata Segment**

  - Segment ID - the segment ID.
  - Type - the segment type.
  - Scope - the segment scope.
  - SysDB Max Seq ID - the maximum sequence ID in the system database.

  **HNSW Segment**

  - Segment ID - the segment ID.
  - Type - the segment type.
  - Scope - the segment scope.
  - Path - the path to the HNSW directory.
  - SysDB Max Seq ID - the maximum sequence ID in the system database.
  - HNSW Dir Size - the size of the HNSW directory.
  - HNSW Metadata Max Seq ID - the maximum sequence ID in the HNSW metadata.
  - HNSW Metadata Total Labels - the total number of labels in the HNSW metadata.
  - WAL Gap - the difference between the maximum sequence ID in the system database and the maximum sequence ID in the
    HNSW
    metadata. The gap usually represents the number of WAL entries that are not committed to the HNSW index.
  - HNSW Raw Total Active Labels - the total number of active labels in the HNSW index.
  - HNSW Raw Allocated Labels - the total number of allocated labels in the HNSW index.
  - HNSW Orphan Labels - a set of orphan labels in the HNSW index. These are labels in the HNSW index that are not visible
    to Chroma as they are not part of the metadata. This set should always be empty, if not please report it!!!
  - Fragmentation Level - the fragmentation level of the HNSW index.



  This command ensures your WAL is committed to binary vector index (HNSW).

  ```bash
  chops commit-wal /path/to/persist_dir
  ```

  > Note: You can skip certain collections by running `chops commit-wal /path/to/persist_dir --skip <collection_name>`



  This command cleans up the committed portion of the WAL and VACUUMs the database.

  ```bash
  chops clean-wal /path/to/persist_dir
  ```



  This commands exports the WAL to a `jsonl` file. The command can be useful in taking backups of the WAL.

  ```bash
  chops export-wal /path/to/persist_dir --out /path/to/export.jsonl
  ```

  > Note: If --out or -o is not specified the command will print the output to stdout.



  This command rebuilds the full-text search index.

  > Note: **_Why is this needed_**? Users have reported broken FTS indices that result in a error of this
  > kind: `no such table: embedding_fulltext_search`

  ```bash
  chops rebuild-fts /path/to/persist_dir
  ```



  > Note: You have to mount your persist directory into the container for the commands to work.


  Building the image:

  ```bash
  docker build -t chops .
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data ghcr.io/amikos-tech/chromadb-ops/chops:latest commit-wal /chroma-data
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data ghcr.io/amikos-tech/chromadb-ops/chops:latest clean-wal /chroma-data
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data -v ./backup:/backup ghcr.io/amikos-tech/chromadb-ops/chops:latest export-wal /chroma-data --out /backup/export.jsonl
  ```



  ```bash
  docker run -it --rm -v ./persist_dir:/chroma-data ghcr.io/amikos-tech/chromadb-ops/chops:latest rebuild-fts /chroma-data
  ```


pkgId: f6471659d9d088ad5505df48b71b1c3be66288ed3dc2048172cbc4cf45fb489a
name: python-chromadbx
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: A collection of experimental Chroma extensions.
url: https://cookbook.chromadb.dev/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromadbx-0.0.6-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install chromadbx
  ```



  - [Query Builder](#queries) - build queries using a builder pattern
  - [ID generation](#id-generation) - generate IDs for documents
  - [Embeddings](docs/embeddings.md) - generate embeddings for your documents:
      - OnnxRuntime embeddings
      - Llama.cpp embeddings
      - Google Vertex AI embeddings
      - Mistral AI embeddings
      - Cloudflare Workers AI embeddings





  Supported filters:

  - `$eq` - equal to (string, int, float)
  - `$ne` - not equal to (string, int, float)
  - `$gt` - greater than (int, float)
  - `$gte` - greater than or equal to (int, float)
  - `$lt` - less than (int, float)
  - `$lte` - less than or equal to (int, float)
  - `$in` - in (list of strings, ints, floats,bools)
  - `$nin` - not in (list of strings, ints, floats,bools)

  **Where:**


  ```python
  import chromadb

  from chromadbx.core.queries import eq, where, ne, and_

  client = chromadb.PersistentClient(path="path/to/db")
  collection = client.get_collection("collection_name")
  collection.query(where=where(and_(eq("a", 1), ne("b", "2"))))

  ```

  **Where Document:**

  ```python
  import chromadb

  from chromadbx.core.queries import where_document, contains, not_contains, LogicalOperator

  client = chromadb.PersistentClient(path="path/to/db")
  collection = client.get_collection("collection_name")
  collection.query(where_document=where_document(contains("this is a document", "this is another document")))

  collection.query(
      where_document=where_document(contains("this is a document", "this is another document", op=LogicalOperator.OR)))

  ```



  ```python
  import chromadb
  from chromadbx import IDGenerator
  from functools import partial
  from typing import Generator

  def sequential_generator(start: int = 0) -> Generator[str, None, None]:
          _next = start
          while True:
              yield f"{_next}"
              _next += 1
  client = chromadb.Client()
  col = client.get_or_create_collection("test")
  my_docs = [f"Document {_}" for _ in range(10)]
  idgen = IDGenerator(len(my_docs), generator=partial(sequential_generator, start=10))
  col.add(ids=idgen, documents=my_docs)
  ```



  ```python
  import chromadb
  from chromadbx import UUIDGenerator

  client = chromadb.Client()
  col = client.get_or_create_collection("test")
  my_docs = [f"Document {_}" for _ in range(10)]
  col.add(ids=UUIDGenerator(len(my_docs)), documents=my_docs)
  ```



  ```python
  import chromadb
  from chromadbx import ULIDGenerator
  client = chromadb.Client()
  col = client.get_or_create_collection("test")
  my_docs = [f"Document {_}" for _ in range(10)]
  col.add(ids=ULIDGenerator(len(my_docs)), documents=my_docs)
  ```



  **Random SHA256:**

  ```python
  import chromadb
  from chromadbx import RandomSHA256Generator
  client = chromadb.Client()
  col = client.get_or_create_collection("test")
  my_docs = [f"Document {_}" for _ in range(10)]
  col.add(ids=RandomSHA256Generator(len(my_docs)), documents=my_docs)
  ```

  **Document-based SHA256:**

  ```python
  import chromadb
  from chromadbx import DocumentSHA256Generator
  client = chromadb.Client()
  col = client.get_or_create_collection("test")
  my_docs = [f"Document {_}" for _ in range(10)]
  col.add(ids=DocumentSHA256Generator(documents=my_docs), documents=my_docs)
  ```



  ```python
  import chromadb
  from chromadbx import NanoIDGenerator
  client = chromadb.Client()
  col = client.get_or_create_collection("test")
  my_docs = [f"Document {_}" for _ in range(10)]
  col.add(ids=NanoIDGenerator(len(my_docs)), documents=my_docs)
  ```


pkgId: eef5f195316634a3f374e265d2c587aa7bdae432ecc3f2b169e17d90e2715b23
name: python-chromaterm
arch: src
version: 0.10.7
epoch: 0
release: 1
summary: Color your Terminal with Regex!
url: https://github.com/hSaria/ChromaTerm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromaterm-0.10.7-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://img.shields.io/github/workflow/status/hSaria/ChromaTerm/CI/main)](https://github.com/hSaria/ChromaTerm/actions?query=workflow%3ACI)
  [![Coverage status](https://coveralls.io/repos/github/hSaria/ChromaTerm/badge.svg)](https://coveralls.io/github/hSaria/ChromaTerm)
  [![Downloads](https://static.pepy.tech/personalized-badge/chromaterm?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=downloads)](https://pepy.tech/project/chromaterm)
  [![Maintainability](https://img.shields.io/codeclimate/maintainability/hSaria/ChromaTerm)](https://codeclimate.com/github/hSaria/ChromaTerm)
  [![PyPI version](https://badge.fury.io/py/chromaterm.svg)](https://badge.fury.io/py/chromaterm)

  ChromaTerm (`ct`) is a Python script that colors your terminal's output using
  regular expressions. It even works with interactive programs, like SSH.

  ![alt text](https://github.com/hSaria/ChromaTerm/raw/main/.github/junos-show-interface.png "Example output")



  ```shell
  pip3 install chromaterm
  ```



  Prefix your command with `ct`. It's that simple.

  ```shell
  ct ssh somewhere
  ```

  You can also pipe data into `ct`, but some programs behave differently when piped,
  like `less` would output the entire file.

  ```shell
  echo "Jul 14 12:28:19  Message from 1.2.3.4: Completed successfully" | ct
  ```



  To always highlight a program, set up an alias in your `.bash_profile`. For
  instance, here's one for `ssh`.

  ```shell
  alias ssh="ct ssh"
  ```

  If you want to highlight your entire terminal, have ChromaTerm spawn your shell by
  modifying the shell command in your terminal's settings to `/usr/local/bin/ct /bin/bash --login`.
  Replace `/bin/bash` with your shell of choice.



  ChromaTerm reads highlight rules from a YAML configuration file, formatted like so:

  ```yaml
  rules:
  - description: Obligatory "Hello, World"
    regex: Hello,?\s+World
    color: f#ff0000

  - description: Spit some facts (emphasize "NOT" so they get it)
    regex: Pineapple does (NOT) belong on pizza
    color:
      0: bold
      1: blink italic underline
  ```

  The configuration file can be placed in one of the locations below. The first one
  found is used.

   * `$HOME/.chromaterm.yml`
   * `$XDG_CONFIG_HOME/chromaterm/chromaterm.yml` (`$XDG_CONFIG_HOME` defaults to
   `$HOME/.config`)
   * `/etc/chromaterm/chromaterm.yml`

  If no file is found, a default one is created in your home directory.

  > Check out [`contrib/rules`](https://github.com/hSaria/ChromaTerm/tree/main/contrib/rules);
  > it has some topic-specific rules that are not included in the defaults.



  Optional. It's purely for your sake.



  The RegEx engine used is Python's [re](https://docs.python.org/3/library/re.html),
  but it can be switched to PCRE2 (see relevant section below).





  The color is a hex string prefixed by `b` for background (e.g. `b#123456`) and
  `f` for foreground (e.g. `f#abcdef`).



  In addition to the background and foreground, you can also use `blink`, `bold`,
  `invert`, `italic`, `strike`, and `underline`. Though, not all terminals support
  those styles; you might not see their effects.



  Colors can be applied per RegEx group (see the 2nd example rule). Any group in
  the RegEx can be referenced, including group `0` (entire match) and
  [named groups](https://docs.python.org/3/howto/regex.html#non-capturing-and-named-groups).



  When multiple rules match the same text, ChromaTerm highlights the text with all
  of the colors of the matching rules. If you want the text to be highlighted only
  by the first rule that matches it, use the `exclusive` flag.

  ```yaml
  - regex: hello
    color: bold
    exclusive: true
  ```

  In the code above, no other rule will highlight `hello`, unless it comes first
  and has the `exclusive` flag set.



  You can define colors in a palette and reference them by name. For instance:

  ```yaml
  palette:
    
    purple-1: '#9140f5'
    purple-2: '#bd5df6'
    purple-3: '#e879f6'

  rules:
  - regex: hello
    color: f.purple-1

  - regex: hi
    color: b.purple-3
  ```

  When referencing a palette color, prefix it with `b.` for background and `f.` for
  foreground.



  If the `PCRE2` library is present, you can use it instead of Python's `re`
  engine. When present, an option in `ct -h` becomes available.

  While the performance improvement is significant (~2x), the two RegEx engines
  have a few differences; use this option only if you have a good understanding
  of their unique features.

  > The default rules work on both engines.



  If you've got any questions or suggestions, please open up an
  [issue](https://github.com/hSaria/ChromaTerm/issues/new/choose) (always
  appreciated).



  To use ChromaTerm on Windows, you will need to run it with the
  [Windows Subsystem for Linux (`WSL`)](https://docs.microsoft.com/en-us/windows/wsl/about)


pkgId: f070864ca68a9526b4f61fb53cce7b743e53eb6c826b768c9dc76cea3dec4a92
name: python-chromatic_tda
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Tool to compute six-packs of persistence diagrams for chromatic point clouds
url: https://github.com/OnDraganov/chromatic-tda
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromatic_tda-1.1.6-1.src.rpm
checksum_type: sha256
description:
  `chromatic_tda` is a package for computing six-packs of persistent diagrams of colored point clouds, such as cells on a tissue slide with an information about their type; or 3D stucture of a material composed of different atoms. The six-pack is a topological summary of capturing many aspects of how the different types of points mingle. It consists of kernel, domain, image, codomain, cokernel and relative persistence diagrams.

  The main purpose of the code is to provide implementation to experiment with chromatic topological data analysis. Although not completely naive, many aspects of the code can be optimised, especially if only part of the infomration from the six-packs turns out to be interesting in a given application.

  The code gives no restriction on the dimension of points or number of colors, but the complexity quickly grows in both parameters. The expected use is points in 2D or 3D with 2 or 3 colors for hundreds to a few thousand points, but both can be increased for toy examples with small numbers of points.





  The package is uploaded to [PyPI](https://pypi.org/project/chromatic-tda/), so it can be installed with `pip`.

  Run `pip install chromatic_tda`.



  From the `dist` folder of the project, you can download the file `chromatic_tda-<version>.tar.gz`, and install it using `pip` as `pip install <path to the file>`.



  The project uses `poetry` for Python dependecy management, which allows you to easily install all you need to run the package:

  - Clone the repository
  - Install `poetry`
  - Go to the repository folder in terminal
  - Run `poetry shell`
  - Run `poetry install`
  - [optional] Run `poetry run pytest` to check that the code runs correctly



  The basic use of the package is as follows:
  ```
  import chromatic_tda as chro
  points, labels = ... # load points, labels
  chro_alpha = chro.ChromaticAlphaComplex(points, labels) simplicial_complex = chro_alpha.get_simplicial_complex(
               sub_complex=‘bi-chromatic’
               full_complex=‘all’
               relative=‘mono-chromatic’
  )  # these options make sense for three colors; for two use, e.g., just sub_complex='mono-chromatic'
  six_pack = simplicial_complex.bars_six_pack()
  chro.plot_six_pack(six_pack)
  ```

  For more details check the docstrings of the methods and the jupyter notebook file `manual` (in [github repo](https://github.com/OnDraganov/chromatic-tda)). For more background on the theory, check the resources listed below.




  The code is based on research done at Institute of Science and Technology by Ranita Biswas, Sebastiano Cultrera di Montesano, Ondřej Draganov, Herbert Edelsbrunner and Morteza Saghafian. A preprint of the full paper can be found on arXiv: [Chromatic Alpha Complexes](https://arxiv.org/abs/2212.03128). A shorter introduction to the main ideas can be found in a preprint [Chromatic Topological Data Analysis](https://arxiv.org/abs/2406.04102).

  A presentation about the main concepts used in this package can be viewed on YouTube: [AATRN Online Seminar: TDA for Chromatic Point Clouds](https://youtu.be/HIqiF00yKaw). A recording of a complementary talk focusing more on the motivations of the work and the combinatorial structures underlying it is accessible through [google drive](https://drive.google.com/file/d/1RBiGlgY4mlRL59eAVmMLrgBCZYN97QnZ/view).



  If you have any questions to the code, do not hesitate to contat us. We are also eager to hear from you if you try the code out, and happy to chat about how you can use it on your data. Use, e.g., the mail in my [github profile](https://github.com/OnDraganov).



  For a rough idea on the performance, see the two plots below showing times the code took on my laptop.
  <img src="img/timing_1.1.1.png" width="500px">
  <img src="img/timing_2d_2c_200exp.png" width="500px">


  Copyright ©2023. Institute of Science and Technology Austria (IST Austria). All Rights Reserved.

  This file is part of chromatic_tda, which is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or 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 Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

  Contact the Technology Transfer Office, ISTA, Am Campus 1, A-3400 Klosterneuburg, Austria, +43-(0)2243 9000, twist@ist.ac.at, for commercial licensing opportunities.


pkgId: 824180627783300379644088574628f6437d3020e9c72c23e984cea9d3db2df9
name: python-chromatrace
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Advanced Python logging with tracing, coloring and FastAPI integration
url: https://github.com/Msameim181/Python-Logging-Best-Practice
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromatrace-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Chromatrace is a Python package designed for advanced logging capabilities, including trace and request ID management. It provides a flexible logging configuration and supports colored logging for better visibility.



  - Configurable logging settings using Pydantic.
  - Support for trace IDs and request IDs.
  - Customizable log formats and handlers.
  - Asynchronous and synchronous function tracing.



  You can install Chromatrace via pip:

  ```bash
  pip install chromatrace
  ```



  To use Chromatrace in your application, you can import the necessary components:

  ```python
  from chromatrace import LoggingSettings, LoggingConfig, tracer
  ```

  Configure your logging settings:

  ```python
  logging_config = LoggingConfig(
      settings=LoggingSettings(),
      application_level='Development',
      enable_tracing=True,
      ignore_nan_trace=True
  )
  logger = logging_config.get_logger(__name__)
  ```

  Use the `tracer` decorator to trace your functions:

  ```python
  @tracer
  async def my_async_function():
      
  ```



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

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


pkgId: b4ae040567dd3cce9249ac956882281ccdd4b8a56dd852177ee3d7c35d2f2932
name: python-chromatrace
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Advanced Python logging with tracing, coloring and FastAPI integration
url: https://github.com/Msameim181/Python-Logging-Best-Practice
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromatrace-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Chromatrace is a Python package designed for advanced logging capabilities, including trace and request ID management. It provides a flexible logging configuration and supports colored logging for better visibility.

  I believe that logging is an essential part of any application, and it is crucial to have a well-organized and structured logging system. Chromatrace aims to provide a simple and easy-to-use logging system that can be integrated into any Python application.
  In simple terms, Chromatrace is a Best Practice of Logging in Python.



  - Configurable logging settings using Pydantic.
  - Customizable log levels and loggers for different services.
  - Support for trace IDs and request IDs.
  - Customizable log formats and handlers.
  - Asynchronous and synchronous function tracing.



  You can install Chromatrace via pip:

  ```bash
  pip install chromatrace
  ```



  To use Chromatrace in your application, you can import the necessary components:

  ```python
  from chromatrace import LoggingSettings, LoggingConfig, tracer
  ```

  Configure your logging settings:

  ```python
  logging_config = LoggingConfig(
      settings=LoggingSettings(),
      application_level='Development',
      enable_tracing=True,
      ignore_nan_trace=True
  )
  logger = logging_config.get_logger(__name__)
  ```

  Use the `tracer` decorator to trace your functions:

  ```python
  @tracer
  async def my_async_function():
     logger.debug("Check something")
     logger.info("Doing something")
     logger.warning("Doing something")
     logger.error("Something went wrong")
  ```



  ```python
  from lagom import Container

  container = Container()

  from chromatrace import LoggingConfig, LoggingSettings

  container[LoggingSettings] = LoggingSettings()
  container[LoggingConfig] = LoggingConfig(
      container[LoggingSettings],
      application_level='Development',
      enable_tracing=True,
      ignore_nan_trace=True
  )
  ```

  Then, add the `LoggingConfig` to your service:

  ```python
  import logging

  from chromatrace import LoggingConfig


  class SomeService:
      def __init__(self, logging_config: LoggingConfig):
          self.logger = logging_config.get_logger(self.__class__.__name__)
          self.logger.setLevel(logging.ERROR)

      async def do_something(self):
          self.logger.debug("Check something in second service")
          self.logger.info("Doing something in second service")
          self.logger.error("Something went wrong in second service")
  ```

  Results:
  ```log
  [Development]-(2024-11-21 23:43:26)-[INFO]-[APIService]-FILENAME:api_app.py-FUNC:do_something-THREAD:MainThread-LINE:27 ::
  Doing something in API service

  [Development]-(2024-11-21 23:43:26)-[ERROR]-[APIService]-FILENAME:api_app.py-FUNC:do_something-THREAD:MainThread-LINE:28 ::
  Something went wrong in API service

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[INFO]-[Main]-FILENAME:main.py-FUNC:main-THREAD:MainThread-LINE:21 ::
  Starting main

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[ERROR]-[ExampleService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:26 ::
  Something went wrong

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[INFO]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:13 ::
  Doing something in second service

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[ERROR]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:14 ::
  Something went wrong in second service

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[DEBUG]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:12 ::
  Check something

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[INFO]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:13 ::
  Doing something

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[WARNING]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:14 ::
  Doing something

  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[ERROR]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:15 ::
  Something went wrong
  ```

  The two first log was out of trace and the trace ID was not added to the log message. The rest of the logs were within the trace and the trace ID - `T-dc1be4de`, was added to the log message.

  **NOTE**: The important thing is that each Class or Service can have its own log level. This is useful when you want to have different log levels for different services.



  ```python
  from chromatrace import RequestIdMiddleware

  app = FastAPI()
  app.add_middleware(RequestIdMiddleware)
  ```

  Result:
  ```log
  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[INFO]-[APIService]-FILENAME:api_app.py-FUNC:read_root-THREAD:MainThread-LINE:38 ::
  Hello World

  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[ERROR]-[ExampleService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:26 ::
  Something went wrong

  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[INFO]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:13 ::
  Doing something in second service

  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[ERROR]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:14 ::
  Something went wrong in second service
  ```

  As you can see, the request ID - `R-ffe0a9a2` is automatically added to the log messages from the thread that handles the request.




  You can find examples of how to use Chromatrace in the [examples](src/exmples/) directory. Run the examples using the following command:

  ```bash
  python main.py
  ```

  Then, run:

  ```bash
  curl 0.0.0.0:8000
  ```

  Now, check the logs in the terminal. :)



  This project is licensed under the GNU AFFERO GENERAL PUBLIC LICENSE - see the [LICENSE](LICENSE) file for details.



  - [Python Logging Best Practices Tips](https://coralogix.com/blog/python-logging-best-practices-tips/)
  - [12 Python Logging Best Practices To Debug Apps Faster](https://middleware.io/blog/python-logging-best-practices/)
  - [10 Best Practices for Logging in Python](https://betterstack.com/community/guides/logging/python/python-logging-best-practices/)

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


pkgId: faee9386d1c525e6cc40291ad4e8d0d12c375b9266fe77d3f6531c172ff85a7c
name: python-chromatrace
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Advanced Python logging with tracing, coloring and FastAPI integration
url: https://github.com/Msameim181/Python-Logging-Best-Practice
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromatrace-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/Msameim181/Python-Logging-Best-Practice.svg)]()
  [![Version](https://badge.fury.io/gh/Msameim181%2FPython-Logging-Best-Practice.svg)](https://badge.fury.io/gh/Msameim181%2FPython-Logging-Best-Practice)
  [![GitHub Release](https://img.shields.io/github/release/Msameim181/Python-Logging-Best-Practice.svg?style=flat)]()
  [![GitHub Release Date](https://img.shields.io/github/release-date/Msameim181/Python-Logging-Best-Practice.svg?style=flat)]()
  [![GitHub Release Date](https://img.shields.io/github/last-commit/Msameim181/Python-Logging-Best-Practice.svg?style=flat)]()
  [![GitHub issues](https://img.shields.io/github/issues/Msameim181/Python-Logging-Best-Practice.svg)]()
  [![PyPi Version](https://img.shields.io/pypi/v/chromatrace.svg)](https://pypi.python.org/pypi/chromatrace/)
  [![PyPi Version Alt](https://badge.fury.io/py/chromatrace.svg)](https://pypi.python.org/pypi/chromatrace/)
  ![PyPI Downloads](https://static.pepy.tech/badge/chromatrace)
  [![Python Versions](https://img.shields.io/pypi/pyversions/chromatrace.svg)]()
  Chromatrace is a Python package designed for advanced logging capabilities, including trace and request ID management. It provides a flexible logging configuration and supports colored logging for better visibility.
  I believe that logging is an essential part of any application, and it is crucial to have a well-organized and structured logging system. Chromatrace aims to provide a simple and easy-to-use logging system that can be integrated into any Python application.
  In simple terms, Chromatrace is a Best Practice of Logging in Python.

  - Configurable logging settings using Pydantic.
  - Customizable log levels and loggers for different services.
  - Support for trace IDs and request IDs.
  - Customizable log formats and handlers.
  - Asynchronous and synchronous function tracing.

  You can install Chromatrace via pip:
  ```bash
  pip install chromatrace
  ```

  To use Chromatrace in your application, you can import the necessary components:
  ```python
  from chromatrace import LoggingSettings, LoggingConfig, tracer
  ```
  Configure your logging settings:
  ```python
  logging_config = LoggingConfig(
      settings=LoggingSettings(),
      application_level='Development',
      enable_tracing=True,
      ignore_nan_trace=True
  )
  logger = logging_config.get_logger(__name__)
  ```
  Use the `tracer` decorator to trace your functions:
  ```python
  @tracer
  async def my_async_function():
     logger.debug("Check something")
     logger.info("Doing something")
     logger.warning("Doing something")
     logger.error("Something went wrong")
  ```

  ```python
  from lagom import Container
  container = Container()
  from chromatrace import LoggingConfig, LoggingSettings
  container[LoggingSettings] = LoggingSettings()
  container[LoggingConfig] = LoggingConfig(
      container[LoggingSettings],
      application_level='Development',
      enable_tracing=True,
      ignore_nan_trace=True
  )
  ```
  Then, add the `LoggingConfig` to your service:
  ```python
  import logging
  from chromatrace import LoggingConfig
  class SomeService:
      def __init__(self, logging_config: LoggingConfig):
          self.logger = logging_config.get_logger(self.__class__.__name__)
          self.logger.setLevel(logging.ERROR)
      async def do_something(self):
          self.logger.debug("Check something in second service")
          self.logger.info("Doing something in second service")
          self.logger.error("Something went wrong in second service")
  ```
  Results:
  ```log
  [Development]-(2024-11-21 23:43:26)-[INFO]-[APIService]-FILENAME:api_app.py-FUNC:do_something-THREAD:MainThread-LINE:27 ::
  Doing something in API service
  [Development]-(2024-11-21 23:43:26)-[ERROR]-[APIService]-FILENAME:api_app.py-FUNC:do_something-THREAD:MainThread-LINE:28 ::
  Something went wrong in API service
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[INFO]-[Main]-FILENAME:main.py-FUNC:main-THREAD:MainThread-LINE:21 ::
  Starting main
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[ERROR]-[ExampleService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:26 ::
  Something went wrong
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[INFO]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:13 ::
  Doing something in second service
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[ERROR]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:14 ::
  Something went wrong in second service
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[DEBUG]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:12 ::
  Check something
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[INFO]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:13 ::
  Doing something
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[WARNING]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:14 ::
  Doing something
  [T-dc1be4de]-[Development]-(2024-11-21 23:43:26)-[ERROR]-[AnotherSample]-FILENAME:sample.py-FUNC:do_something-THREAD:MainThread-LINE:15 ::
  Something went wrong
  ```
  The two first log was out of trace and the trace ID was not added to the log message. The rest of the logs were within the trace and the trace ID - `T-dc1be4de`, was added to the log message.
  **NOTE**: The important thing is that each Class or Service can have its own log level. This is useful when you want to have different log levels for different services.

  ```python
  from chromatrace import RequestIdMiddleware
  app = FastAPI()
  app.add_middleware(RequestIdMiddleware)
  ```
  Result:
  ```log
  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[INFO]-[APIService]-FILENAME:api_app.py-FUNC:read_root-THREAD:MainThread-LINE:38 ::
  Hello World
  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[ERROR]-[ExampleService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:26 ::
  Something went wrong
  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[INFO]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:13 ::
  Doing something in second service
  [R-ffe0a9a2]-[Development]-(2024-11-22 00:13:53)-[ERROR]-[InnerService]-FILENAME:example_service.py-FUNC:do_something-THREAD:MainThread-LINE:14 ::
  Something went wrong in second service
  ```
  As you can see, the request ID - `R-ffe0a9a2` is automatically added to the log messages from the thread that handles the request.

  ```python
  from chromatrace import SocketRequestIdMiddleware
  socket_application = SocketRequestIdMiddleware(socket_application)
  ```
  The full example can be found in the [socket_app.py](src/examples/socket_app.py) file. I recommend you to check it out before making any decision. The client-side code can be found in the [socket_client.py](src/examples/socket_client.py) file.
  Result:
  ```log
  [S-4e2b7c5e]-[Development]-(2024-12-06 01:15:18)-[INFO]-[Socket]-FILENAME:socket_app.py-FUNC:connect-THREAD:MainThread-LINE:86 ::
  Socket connected on main namespace. SID: wB-srwnv9Xa2w_8bAAAB
  [S-4e2b7c5e]-[Development]-(2024-12-06 01:15:20)-[INFO]-[Socket]-FILENAME:socket_app.py-FUNC:message-THREAD:MainThread-LINE:90 ::
  Received message on main namespace. SID: wB-srwnv9Xa2w_8bAAAB, Message: Hello from the client
  [S-aaf46528]-[Development]-(2024-12-06 01:15:47)-[INFO]-[Socket]-FILENAME:socket_app.py-FUNC:connect-THREAD:MainThread-LINE:86 ::
  Socket connected on main namespace. SID: FI3E_S_A-KsTi4RLAAAD
  [S-aaf46528]-[Development]-(2024-12-06 01:15:49)-[INFO]-[Socket]-FILENAME:socket_app.py-FUNC:message-THREAD:MainThread-LINE:90 ::
  Received message on main namespace. SID: FI3E_S_A-KsTi4RLAAAD, Message: Hello from the client
  ```
  Yes, the socket logs are also within the trace. The trace ID - `S-4e2b7c5e` and `S-aaf46528` was added to the log messages. For better experience, the prefix `S` was added to the trace ID to differentiate it from the request ID.

  > You don't trust me, do you? I understand. You wanna see it in action, right? I got you covered. :)
  You can find examples of how to use Chromatrace in the [examples](src/examples/) directory. Run the examples using the following command:
  ```bash
  python main.py
  ```
  Then, run:
  ```bash
  curl 0.0.0.0:8000
  ```
  Now, check the logs in the terminal.
  Also, the socket server will start and wait for the client to connect on `http://localhost:8001`.
  For socket client-side run the following command in another terminal:
  ```bash
  python socket_client.py
  ```
  Now, check the logs in the both terminal.

  This project is licensed under the GNU AFFERO GENERAL PUBLIC LICENSE - see the [LICENSE](LICENSE) file for details.

  - [Python Logging Best Practices Tips](https://coralogix.com/blog/python-logging-best-practices-tips/)
  - [12 Python Logging Best Practices To Debug Apps Faster](https://middleware.io/blog/python-logging-best-practices/)
  - [10 Best Practices for Logging in Python](https://betterstack.com/community/guides/logging/python/python-logging-best-practices/)

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


pkgId: dd571ad6be539c7733e20140ccf3753fc8f9a657f7fcc979a2b1353c436b1e6e
name: python-chrome-devtools-protocol
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Python type wrappers for Chrome DevTools Protocol (CDP)
url: https://github.com/hyperiongray/python-chrome-devtools-protocol
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrome-devtools-protocol-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/chrome-devtools-protocol.svg)](https://pypi.org/project/chrome-devtools-protocol/)
  ![Python Versions](https://img.shields.io/pypi/pyversions/chrome-devtools-protocol)
  ![MIT License](https://img.shields.io/github/license/HyperionGray/python-chrome-devtools-protocol.svg)
  [![Build Status](https://img.shields.io/travis/com/HyperionGray/python-chrome-devtools-protocol.svg?branch=master)](https://travis-ci.com/HyperionGray/python-chrome-devtools-protocol)
  [![Read the Docs](https://img.shields.io/readthedocs/py-cdp.svg)](https://py-cdp.readthedocs.io)

  Python Chrome DevTools Protocol (shortened to PyCDP) is a library that provides
  Python wrappers for the types, commands, and events specified in the [Chrome
  DevTools Protocol](https://github.com/ChromeDevTools/devtools-protocol/).

  The Chrome DevTools Protocol provides for remote control of a web browser by
  sending JSON messages over a WebSocket. That JSON format is described by a
  machine-readable specification. This specification is used to automatically
  generate the classes and methods found in this library.

  You could write a CDP client by connecting a WebSocket and then sending JSON
  objects, but this would be tedious and error-prone: the Python interpreter would
  not catch any typos in your JSON objects, and you wouldn't get autocomplete for
  any parts of the JSON data structure. By providing a set of native Python
  wrappers, this project makes it easier and faster to write CDP client code.

  **This library does not perform any I/O!** In order to maximize
  flexibility, this library does not actually handle any network I/O, such as
  opening a socket or negotiating a WebSocket protocol. Instead, that
  responsibility is left to higher-level libraries, for example
  [trio-chrome-devtools-protocol](https://github.com/hyperiongray/trio-chrome-devtools-protocol).

  For more information, see the [complete documentation](https://py-cdp.readthedocs.io).

  <a href="https://www.hyperiongray.com/?pk_campaign=github&pk_kwd=pycdp"><img alt="define hyperion gray" width="500px" src="https://hyperiongray.s3.amazonaws.com/define-hg.svg"></a>


pkgId: 8e75a4cf1055e667971316b6d4f314c545ac3447ef0a88310f7fcc66e1a4399f
name: python-chrome-extension-python
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/omkarcloud/chrome-extension-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrome-extension-python-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  Chrome Extension Python allows you to easily integrate Chrome extensions in web automation frameworks like Botasaurus, Selenium, and Playwright.

description:
  `Chrome Extension Python` that allows you to easily integrate Chrome extensions in web automation frameworks like Botasaurus, Selenium, and Playwright.

  This tool simplifies the process of downloading, configuring, and using any Chrome extension.



  Install the package using pip:

  ```bash
  python -m pip install chrome_extension_python
  ```



  This package allows the use of Chrome extensions in Botasaurus, Selenium, and Playwright frameworks.

  Below are examples demonstrating the integration of the Adblock extension in each framework.



  [Botasaurus](https://github.com/omkarcloud/botasaurus), a web scraping framework, integrates easily with `Chrome Extension Python`. Pass the Chrome Webstore link of the extension to use it.

  Example with Adblock Extension:

  ```python
  from botasaurus import *
  from chrome_extension_python import Extension

  @browser(
      extensions=[Extension("https://chromewebstore.google.com/detail/adblock-%E2%80%94-best-ad-blocker/gighmmpiobklfepjocnamgkkbiglidom")],
  )
  def open_chrome(driver: AntiDetectDriver, data):
      driver.prompt()

  open_chrome()
  ```



  Integration with Selenium involves setting up Chrome options and adding the extension.

  Example:

  ```python
  from selenium import webdriver
  from selenium.webdriver.chrome.options import Options
  from chromedriver_autoinstaller import install
  from chrome_extension_python import Extension


  options = Options()
  options.add_argument(Extension("https://chromewebstore.google.com/detail/adblock-%E2%80%94-best-ad-blocker/gighmmpiobklfepjocnamgkkbiglidom").load())


  driver_path = install()
  driver = webdriver.Chrome(driver_path, options=options)


  input("Press Enter to exit...")


  driver.quit()
  ```



  Playwright integration includes specifying the extension path and launching the browser context with the extension.

  Example:

  ```python
  from playwright.sync_api import sync_playwright
  from chrome_extension_python import Extension
  import random

  def generate_random_profile():
      return str(random.randint(1, 1000))

  with sync_playwright() as p:
      extension_path = Extension("https://chromewebstore.google.com/detail/adblock-%E2%80%94-best-ad-blocker/gighmmpiobklfepjocnamgkkbiglidom").load(with_command_line_option=False)
      browser = p.chromium.launch_persistent_context(
          user_data_dir=generate_random_profile(),
          headless=False,
          args=[
              '--disable-extensions-except='+ extension_path,
              '--load-extension=' + extension_path,
          ],
      )
      page = browser.new_page()
      input("Press Enter to exit...")
      browser.close()
  ```



  Extensions can be configured either

  - by editing their JavaScript files
  - or by interacting with their UI using Selenium.



  The JavaScript file editing method is faster and more robust. The following example demonstrates creating a configurable CapSolver Extension with an API key:

  ```python
  from chrome_extension_python import Extension

  class Capsolver(Extension):
      def __init__(self, api_key):
          
          super().__init__(
              extension_id="pgojnojmmhpofjgdmaebadhbocahppod",  # Unique identifier for the Chrome Extension, found in the Chrome Webstore link
              extension_name="capsolver",  # The name assigned to the extension
              api_key=api_key,  # An important custom parameter (API key) required for the extension's functionality
          )

      
      def update_files(self, api_key):
          
          js_files = self.get_js_files()

          def update_js_contents(content):
              
              to_replace = "return e.defaultConfig"
              
              replacement = (
                  f"return {{ ...e.defaultConfig, apiKey: '{api_key}' }}"
              )
              
              return content.replace(to_replace, replacement)

          
          for file in js_files:
              file.update_contents(update_js_contents)

          
          config_file = self.get_file("/assets/config.js")

          def update_config_contents(content):
              
              key_replaced = content.replace("apiKey: '',", f"

  apiKey: '{api_key}',")
              return key_replaced

          
          config_file.update_contents(update_config_contents)
  ```

  Usage Example:

  ```python
  from botasaurus import *

  @browser(
      extensions=[Capsolver(api_key="CAP-MY_KEY")],
  )
  def open_chrome(driver: AntiDetectDriver, data):
      driver.get("https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php")
      driver.prompt()

  open_chrome()
  ```



  For custom extension development, the following methods are available:

  - `get_js_files`, `get_json_files`, `get_html_files`, `get_css_files`: Recursively retrieves specified file types.
  - `get_file`: Retrieves a specific file as a `File` object.
  - `File.update_contents`: Updates the content of a file.
  - `force_update` (defaults to False): Redownload the extension and call `update_files` when extension data changes. It is recommended to set it to `True` during active development.

  Example of a custom extension with `force_update`:

  ```python
  from chrome_extension_python import Extension

  class CustomExtension(Extension):
      def __init__(self, api_key):
          
          super().__init__(
              extension_id="pgojnojmmhpofjgdmaebadhbocahppod", # Unique identifier for the Chrome Extension, obtained from the Chrome Webstore link
              extension_name="capsolver", # The name assigned to the extension
              force_update=True, # This flag, when set to True, forces the redownload of the extension and calls the `update_files` method. This is useful during development to ensure updates are applied.
          )
  ```


  Here are some code snippets of Custom Extensions to provide you with an idea of how to develop your own.

  - [Capsolver Extension](https://github.com/omkarcloud/capsolver-extension-python)
  - [2captcha Extension](https://github.com/omkarcloud/2captcha-extension-python)



  If you wish to share your extension with other developers via PyPI, follow these steps:

  1. Clone the template repository: [capsolver-extension-python](https://github.com/omkarcloud/capsolver-extension-python).
  2. Replace references to "capsolver" with your extension's name.
  3. Rename the `capsolver_extension_python` folder to match your extension name.
  4. Insert your extension code in `__init__.py`.
  5. Update README.md
  6. Use `npm run upload` to publish the extension on PyPI.

  Contact us at `chetan@omkar.cloud` with details about your extension. If it's beneficial for web scrapers, we'll promote it within the Botasaurus community.



  Become one of our amazing stargazers by giving us a star ⭐ on GitHub!

  It's just one click, but it means the world to me.

  [![Stargazers for @omkarcloud/chrome-extension-python](https://bytecrank.com/nastyox/reporoster/php/stargazersSVG.php?user=omkarcloud&repo=chrome-extension-python)](https://github.com/omkarcloud/chrome-extension-python/stargazers)


pkgId: 24789e27a82ff3834ed0e161c1b172740e3c53a06f7ac4b1c2869740898c5b6f
name: python-chrome-fingerprints
arch: src
version: 1.1
epoch: 0
release: 1
url: https://github.com/Vinyzu/chrome-fingerprints
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrome-fingerprints-1.1-1.src.rpm
checksum_type: sha256
summary:
  A Collection of 10.000 self-collected Chrome Fingerprints. Wrapped in a easy-to-use API, available as a Compressed or Full-Size Json.

description:
  ```py
  from chrome_fingerprints import FingerprintGenerator, ChromeFingerprint
  fp_gen = FingerprintGenerator()
  fingerprint: ChromeFingerprint = fp_gen.get_fingerprint()
  ```

  ```py
  import asyncio
  from chrome_fingerprints.fingerprints import AsyncFingerprintGenerator, ChromeFingerprint
  async def main():
      fp_gen = AsyncFingerprintGenerator()
      fingerprint: ChromeFingerprint = await fp_gen.get_fingerprint()
  if __name__ == '__main__':
      asyncio.run(main())


pkgId: b3d8f983361fc8ca6d5037532f2926b4d0239c2dc90a5612bbf80f825d776542
name: python-chrome-lens-py
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Library to use Google Lens OCR for free via API used in Chromium on python
url: https://github.com/bropines/chrome-lens-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrome-lens-py-1.3.2-1.src.rpm
checksum_type: sha256
description:
  [English](/README.md) | [Русский](/README_RU.md)

  This project provides a Python library and CLI tool for interacting with Google Lens's OCR functionality via the API used in Chromium. This allows you to process images and extract text data, including full text, coordinates, and stitched text using various methods.



  - **Extract the full text**: Extract the full text from the image.
  - **Coordinate Extraction**: Extract the text along with its coordinates.
  - **Stitched text**: Restore text from coordinate blocks using various methods:
    - **Old method**: Sequential stitching of text.
    - **New method**: Improved text stitching by calculating them line by line. It is not recommended on rotated texts. Use the past one.
  - **Scan images from URLs**: Process images directly from URLs without downloading them manually.
  - **Cookie Management**: Download and manage cookies from a file in Netscape format or directly through the configuration.
  - **Proxy Support**: Supports HTTP, HTTPS, and SOCKS4/5 proxies to make requests over different networks.

  _PS: Lens has a problem with the way it displays full text, which is why methods have been added that stitch text from coordinates._



  You can install the package using `pip`:



  ```bash
  pip install chrome-lens-py
  ```



  ```bash
  pip install -U chrome-lens-py
  ```



  ```bash
  pip install git+https://github.com/bropines/chrome-lens-py.git
  ```



  Clone the repository and install the package:

  ```bash
  git clone https://github.com/bropines/chrome-lens-api-py.git
  cd chrome-lens-api-py
  pip install -r requirements.txt
  pip install .
  ```



  You can use the `lens_scan` command from the CLI to process images and extract text data, or you can use the Python API to integrate this functionality into your own projects.

  <details>
    <summary><b>CLI Usage</b></summary>

  ```bash
  lens_scan <image_source> <data_type>
  ```

  - `<image_source>`: Path to the image file or URL.
  - `<data_type>`: Type of data to extract (see below).



  - **all**: Get all data (full text, coordinates, and stitched text using both methods).
  - **full_text_default**: Get only the default full text.
  - **full_text_old_method**: Get stitched text using the old sequential method.
  - **full_text_new_method**: Get stitched text using the new enhanced method.
  - **coordinates**: Get text along with coordinates.



  To extract text using the new method for stitching from a local file:

  ```bash
  lens_scan path/to/image.jpg full_text_new_method
  ```

  To extract text using the new method for stitching from a URL:

  ```bash
  lens_scan https://example.com/image.jpg full_text_new_method
  ```

  To get all available data from a local file:

  ```bash
  lens_scan path/to/image.jpg all
  ```

  To get all available data from a URL:

  ```bash
  lens_scan https://example.com/image.jpg all
  ```



  You can use the `-h` or `--help` option to display usage information:

  ```bash
  lens_scan -h
  ```

  </details>

  <details>
    <summary><b>Programmatic API Usage</b></summary>

  In addition to the CLI tool, this project provides a Python API that can be used in your scripts.



  First, import the `LensAPI` class:

  ```python
  from chrome_lens_py import LensAPI
  ```



  1. **Instantiate the API**:

     ```python
     api = LensAPI()
     ```
  2. **Process an image**:

     - **Get all data from a local file**:

       ```python
       result = api.get_all_data('path/to/image.jpg')
       print(result)
       ```
     - **Get all data from a URL**:

       ```python
       result = api.get_all_data('https://example.com/image.jpg')
       print(result)
       ```
     - **Get the default full text from a local file**:

       ```python
       result = api.get_full_text('path/to/image.jpg')
       print(result)
       ```
     - **Get the default full text from a URL**:

       ```python
       result = api.get_full_text('https://example.com/image.jpg')
       print(result)
       ```
     - **Get stitched text using the old method from a local file**:

       ```python
       result = api.get_stitched_text_sequential('path/to/image.jpg')
       print(result)
       ```
     - **Get stitched text using the old method from a URL**:

       ```python
       result = api.get_stitched_text_sequential('https://example.com/image.jpg')
       print(result)
       ```
     - **Get stitched text using the new method from a local file**:

       ```python
       result = api.get_stitched_text_smart('path/to/image.jpg')
       print(result)
       ```
     - **Get stitched text using the new method from a URL**:

       ```python
       result = api.get_stitched_text_smart('https://example.com/image.jpg')
       print(result)
       ```
     - **Get text with coordinates from a local file**:

       ```python
       result = api.get_text_with_coordinates('path/to/image.jpg')
       print(result)
       ```
     - **Get text with coordinates from a URL**:

       ```python
       result = api.get_text_with_coordinates('https://example.com/image.jpg')
       print(result)
       ```

  </details>

  <details>
    <summary><b>Cookie Management</b></summary>

  This project supports the management of cookies through various methods.

  To receive cookies in Netscape format, you can use the following extensions:

  - Chrome (Chromium): [Cookie Editor](https://chromewebstore.google.com/detail/cookie-editor/hlkenndednhfkekhgcdicdfddnkalmdm)
  - Firefox: [Cookie Editor](https://addons.mozilla.org/ru/firefox/addon/cookie-editor/)

  1. **Loading Cookies from a Netscape Format File**:

     * You can load cookies from a Netscape format file by specifying the file path.

     **Programmatic API**:

     ```python
     config = {
         'headers': {
             'cookie': '/path/to/cookie_file.txt'
         }
     }
     api = LensAPI(config=config)
     ```

     **CLI**:

     ```bash
     lens_scan path/to/image.jpg all -c /path/to/cookie_file.txt
     ```
  2. **Passing Cookies Directly as a String**:

     * You can also pass cookies directly as a string in the configuration or via CLI.

     **Programmatic API**:

     ```python
     config = {
         'headers': {
             'cookie': '__Secure-ENID=17.SE=-dizH-; NID=511=---bcDwC4fo0--lgfi0n2-'
         }
     }
     api = LensAPI(config=config)
     ```

     or

     ```python
     config = {
         'headers': {
             'cookie': {
                 '__Secure-ENID': {
                     'name': '__Secure-ENID',
                     'value': '',
                     'expires': 1756858205,
                 },
                 'NID': {
                     'name': 'NID',
                     'value': '517=4.......',
                     'expires': 1756858205,
                 }
             }
         }
     }
     api = LensAPI(config=config)
     ```

  </details>

  <details>
    <summary><b>Proxy Support</b></summary>

  You can make requests through a proxy server using the API or CLI. The library supports HTTP, HTTPS, and SOCKS4/5 proxies.

  * **Set Proxy in API**:

    ```python
    config = {
        'proxy': 'socks5://127.0.0.1:2080'
    }
    api = LensAPI(config=config)
    ```
  * **Set Proxy in CLI**:

    ```bash
    lens_scan path/to/image.jpg all -p socks5://127.0.0.1:2080
    ```

  </details>

  <details>
    <summary><b>Programmatic API Methods</b></summary>

  - **`get_all_data(image_source)`**: Returns all available data for the given image source (file path or URL).
  - **`get_full_text(image_source)`**: Returns only the full text from the image source.
  - **`get_text_with_coordinates(image_source)`**: Returns text along with its coordinates in JSON format from the image source.
  - **`get_stitched_text_smart(image_source)`**: Returns stitched text using the enhanced method from the image source.
  - **`get_stitched_text_sequential(image_source)`**: Returns stitched text using the basic sequential method from the image source.

  </details>

  <details>
    <summary><b>Working with Coordinates</b></summary>

  In our project, coordinates are used to define the position, size, and rotation of text on an image. Each text region is described by a set of values that help accurately determine where and how to display the text. Here's how these values are interpreted:

  1. **Y Coordinate**: The first value in the coordinates array represents the vertical position of the top-left corner of the text region on the image. The value is expressed as a fraction of the image's total height, with `0.0` corresponding to the top edge and `1.0` to the bottom.

  2. **X Coordinate**: The second value indicates the horizontal position of the top-left corner of the text region. The value is expressed as a fraction of the image's total width, where `0.0` corresponds to the left edge and `1.0` to the right.

  3. **Width**: The third value represents the width of the text region as a fraction of the image's total width. This value determines how much horizontal space the text will occupy.

  4. **Height**: The fourth value indicates the height of the text region as a fraction of the image's total height.

  5. **Fifth Parameter**: In the current data, this parameter is always zero and appears to be unused. It might be reserved for future use or specific text modifications.

  6. **Sixth Parameter**: Specifies the rotation angle of the text region in degrees. Positive values indicate clockwise rotation, while negative values indicate counterclockwise rotation.

  Coordinates are measured from the top-left corner of the image. This means that `(0.0, 0.0)` corresponds to the very top-left corner of the image, while `(1.0, 1.0)` corresponds to the very bottom-right corner.



  ```json
  {
      "text": "Sample text",
      "coordinates": [
          0.5,
          0.5,
          0.3,
          0.1,
          0,
          -45
      ]
  }
  ```

  In this example:

  - `0.5` — Y coordinate (50% of the image height, text centered vertically).
  - `0.5` — X coordinate (50% of the image width, text centered horizontally).
  - `0.3` — width of the text region (30% of the image width).
  - `0.1` — height of the text region (10% of the image height).
  - `0` — not used, default value (possibly reserved for future use).
  - `-45` — rotation angle of the text counterclockwise by 45 degrees.

  These values are used to accurately place, scale, and display the text on the image.



  You can choose the coordinate output format: percentages or pixels. By default, coordinates are output in percentages, but you can switch to pixels using the appropriate settings.



  When using the command line, you can specify the coordinate format using the `--coordinate-format` flag. Acceptable values are `'percent'` or `'pixels'`.

  **Usage Examples:**

  - **Output coordinates in percentages (default):**

    ```bash
    lens_scan image.jpg coordinates
    ```

  - **Output coordinates in pixels:**

    ```bash
    lens_scan image.jpg coordinates --coordinate-format=pixels
    ```



  When using the programmatic API, you can pass the `coordinate_format` parameter to the methods of the `LensAPI` class. Acceptable values are `'percent'` or `'pixels'`.

  **Usage Example:**

  ```python
  from lens_api import LensAPI

  api = LensAPI()


  image_path = 'image.jpg'


  result = api.get_all_data(image_path, coordinate_format='pixels')

  print(result)
  ```



  - When selecting the `'pixels'` format, coordinates will be calculated relative to the **original dimensions** of the image, even if the image was resized for processing.
  - If the format is not specified, coordinates are output in percentages by default.
  - When working with pixel coordinates, ensure you use the original image for accurate placement of text regions.
  </details>

  <details>
    <summary><b>Debugging and Logging</b></summary>

  When using the CLI tool `lens_scan`, you can control the logging level using the `--debug` flag. There are two levels available:

  - `--debug=info`: Enables logging of informational messages, which include general information about the processing steps.
  - `--debug=debug`: Enables detailed debugging messages, including verbose output and the saving of the raw response from the API to a file named `response_debug.txt` in the current directory.

  **Example Usage:**

  - To run with informational logging:

    ```bash
    lens_scan path/to/image.jpg all --debug=info
    ```

  - To run with detailed debugging logging:

    ```bash
    lens_scan path/to/image.jpg all --debug=debug
    ```

  When using `--debug=debug`, the library will save the raw response from the API to `response_debug.txt` in the current working directory. This can be useful for deep debugging and understanding the exact response from the API.



  When using the API in your Python scripts, you can control the logging level by configuring the logging module and by passing the `logging_level` parameter when instantiating the `LensAPI` class.

  **Example Usage:**

  ```python
  import logging
  from chrome_lens_py import LensAPI


  logging.basicConfig(level=logging.DEBUG)


  api = LensAPI(logging_level=logging.DEBUG)


  result = api.get_all_data('path/to/image.jpg')
  print(result)
  ```

  The `logging_level` parameter accepts standard logging levels from the `logging` module, such as `logging.INFO`, `logging.DEBUG`, etc.

  When the logging level is set to `DEBUG`, the library will output detailed debugging information and save the raw API response to `response_debug.txt` in the current directory.

  The `--debug-out` flag will allow you to specify the path where to save the response from the server, in the case of the debug level `DEBUG`. By default, it is saved, as described above, in the folder where the console is launched, that is, in `CWD`



  - **INFO** level: Provides general information about the process, such as when requests are sent and responses are received.
  - **DEBUG** level: Provides detailed information useful for debugging, including internal state and saved responses.

  </details>

  <details> <summary><b>Configuration Management</b></summary>



  When running the CLI tool `lens_scan`, the application determines settings based on the following priority order (from highest to lowest):

  1. **Command-line arguments (CLI)**: Options specified directly when running the command have the highest priority.
  2. **Environment variables**: If a setting is not specified in the CLI, the application will check for corresponding environment variables.
  3. **Configuration file**: If a setting is not found in the CLI arguments or environment variables, the application will look into the configuration file.
  4. **Default values**: If a setting is not specified in any of the above, default values are used.



  * The default configuration file is located in the user's configuration directory, which varies by operating system:
      * **Windows**: `C:\Users\<YourUserName>\.config\chrome-lens-py\config.json`
      * **Unix/Linux**: `/home/<YourUserName>/.config/chrome-lens-py/config.json`
      * **macOS**: `/Users/<YourUserName>/Library/Application Support/chrome-lens-py/config.json`



  * You can specify a custom configuration file using the `--config-file` flag:

      ```bash
      lens_scan --config-file path/to/your/config.json <image_source> <data_type>
      ```

  * When a custom configuration file is specified, it is treated as read-only and will not be modified by the application.




  The configuration file is a JSON file that can include the following settings:

  * **`proxy`**: Specify a proxy server to route requests.

      ```json
      {
        "proxy": "socks5://username:password@proxy.example.com:1080"
      }
      ```

  * **`cookies`**: Specify cookies to use with requests. This can be a path to a cookies file or a cookie string.

      ```json
      {
        "cookies": "path/to/your/cookie_file.txt"
      }
      ```

      or

      ```json
      {
        "cookies": "__Secure-ENID=17.SE=-dizH-; NID=511=---bcDwC4fo0--lgfi0n2-"
      }
      ```

  * **`coordinate_format`**: Set the format of output coordinates. Acceptable values are `"percent"` or `"pixels"`.

      ```json
      {
        "coordinate_format": "pixels"
      }
      ```

  * **`debug`**: Set the logging level. Acceptable values are `"info"` or `"debug"`.

      ```json
      {
        "debug": "debug"
      }
      ```
  * **`data_type`**: Set the type of [output data](#data-types).

    ```json
    {
      "data_type": "all"
    }



  Here is an example of a configuration file that includes all possible configuration parameters:

  ```json
  {
    "proxy": "socks5://username:password@proxy.example.com:1080",
    "cookies": "path/to/your/cookie_file.txt",
    "coordinate_format": "pixels",
    "debug": "debug"
  }
  ```



  * To update the default configuration file with new settings from the CLI, use the `-uc` or `--update-config` flag.

      ```bash
      lens_scan <image_source> <data_type> [options] -uc
      ```

  * **Note**: The configuration file will only be updated if it's the default configuration file (i.e., not specified via `--config-file`).

  * Only specific settings will be updated:

      * **Settings that can be updated**:

          * `coordinate_format`
          * `debug`
          * `data_type`
      * **Settings that will **not** be updated**:

          * `proxy`
          * `cookies`
          * `image_source`

  * This allows you to persist certain settings across runs without affecting critical configurations like proxy settings or cookies.




  * **Updating the coordinate format in the default configuration file**:

      ```bash
      lens_scan path/to/image.jpg all --coordinate-format=pixels -uc
      ```

      * This command will set the coordinate format to pixels for the current run and update the default configuration file so that future runs will also use pixels as the coordinate format.
  * **Using a proxy without updating the configuration file**:

      ```bash
      lens_scan path/to/image.jpg all -p socks5://127.0.0.1:2080
      ```

      * The proxy setting will be used for this run but will not be saved to the configuration file.
  * **Specifying a custom configuration file (read-only)**:

      ```bash
      lens_scan --config-file path/to/config.json path/to/image.jpg all
      ```

      * The application will use settings from the specified configuration file but will not modify it, even if the `-uc` flag is used.



  You can also specify settings via environment variables:

  * **`LENS_SCAN_PROXY`**: Set the proxy server.

      ```bash
      export LENS_SCAN_PROXY="socks5://username:password@proxy.example.com:1080"
      ```

  * **`LENS_SCAN_COOKIES`**: Provide cookies.

      ```bash
      export LENS_SCAN_COOKIES="__Secure-ENID=17.SE=-dizH-; NID=511=---"
      ```

  * **`LENS_SCAN_CONFIG_PATH`**: Specify a custom configuration file.

      ```bash
      export LENS_SCAN_CONFIG_PATH="path/to/your/config.json"
      ```

  </details>

  <details>
  <summary><b>Batch Processing</b></summary>



  This project supports batch processing of images when a directory path is provided instead of a single image file. The application will process all image files in the specified directory.



  To perform batch processing via the command line, simply provide the path to the directory containing the images instead of a single image file.

  ```bash
  lens_scan path/to/directory <data_type> [options]
  ```

  * **`path/to/directory`**: Path to the directory containing image files.
  * **`<data_type>`**: Type of data to extract (e.g., `all`, `full_text_default`, etc.).
  * **`[options]`**: Additional options such as `--out-txt`.

  **Example:**

  ```bash
  lens_scan /path/to/images all --out-txt=per_file
  ```



  The `--out-txt` flag allows you to control how the output is saved when processing multiple images:

  * **`--out-txt=per_file`**: Outputs each result to a separate text file based on the image name within the same directory.
  * **`--out-txt=filename.txt`**: Outputs all results into a single text file with the specified name within the same directory.
  * **No `--out-txt` flag**: By default, all results are saved into a file named `output.txt` within the same directory.

  **Examples:**

  1. **Output to Separate Files Per Image:**

      ```bash
      lens_scan /path/to/images all --out-txt=per_file
      ```

      This command processes all images in `/path/to/images` and saves each result to a separate text file named after the image (e.g., `image1.txt`, `image2.txt`).

  2. **Output All Results to a Single File:**

      ```bash
      lens_scan /path/to/images all --out-txt=results.txt
      ```

      This command processes all images and saves all results into `results.txt` within the same directory.

  3. **Default Output (output.txt):**

      ```bash
      lens_scan /path/to/images all
      ```

      Without specifying `--out-txt`, the results are saved into `output.txt` within the same directory.




  When outputting to a single file (default behavior or when specifying a filename with `--out-txt`), the format of the output file is:

  ```plaintext

  Extracted text from filename1.jpg


  Extracted text from filename2.png

  ...
  ```

  Each image's extracted text is prefixed with a `#` followed by the filename, and the text retains the original formatting, including newline characters.



  To avoid overwhelming the API and to comply with rate limiting policies, the library introduces a delay between processing each image. By default, this sleep time is set to 1000 milliseconds (1 second). You can adjust this delay using the `-st` or `--sleep-time` flag, specifying the time in milliseconds.

  **Example:**

  ```bash
  lens_scan /path/to/images all -st 500
  ```

  This command sets the sleep time to 500 milliseconds between processing each image.



  You can also perform batch processing using the Python API by providing a directory path to the methods.

  **Example:**

  ```python
  from chrome_lens_py import LensAPI

  api = LensAPI(sleep_time=500)  # Set sleep time to 500 milliseconds


  directory_path = '/path/to/images'


  results = api.get_full_text(directory_path)


  for filename, text in results.items():
      if 'error' in text:
          print(f"Error processing {filename}: {text['error']}")
      else:
          print(f"# {filename}")
          print(text)
          print()
  ```



  * **Supported Image Files**: Only image files with supported MIME types will be processed. Non-image files or unsupported formats will be ignored.
  * **Adjusting Sleep Time**: The sleep time between requests can be adjusted to meet your needs, but be cautious when reducing it to prevent being rate-limited by the API.
  * **Error Handling**: If an error occurs while processing an image, the error message will be stored in the results under that filename.
  * **Output Files**: When using `--out-txt=per_file`, the output text files will be saved in the same directory as the images, with the same base filename and a `.txt` extension.

  </details>




  ```plain
  /chrome-lens-api-py
  │
  ├── /src
  │   ├── /chrome_lens_py
  │   │   ├── __init__.py           # Package initialization
  │   │   ├── constants.py          # Constants used in the project
  │   │   ├── utils.py              # Utility functions
  │   │   ├── image_processing.py   # Image processing module
  │   │   ├── request_handler.py    # API request handling module
  │   │   ├── text_processing.py    # Text processing module
  │   │   ├── lens_api.py           # API interface for use in other scripts
  │   │   └── main.py               # CLI tool entry point
  │
  ├── setup.py                      # Installation setup
  ├── README.md                     # Project description and usage guide
  └── requirements.txt              # Project dependencies
  ```



  Special thanks to [dimdenGD](https://github.com/dimdenGD) for the method of text extraction used in this project. You can check out their work on the [chrome-lens-ocr](https://github.com/dimdenGD/chrome-lens-ocr) repository. This project is inspired by their approach to leveraging Google Lens OCR functionality.



  - [X] Add `scan by url`
  - [X] Add output in pixels
  - [ ] Move all methods from [chrome-lens-ocr](https://github.com/dimdenGD/chrome-lens-ocr)
    - cookie!?
  - [ ] Do everything beautifully, and not like 400 lines of code, cut into modules by GPT chat
  - [ ] Something else very, very important...



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.



  This project is intended for educational purposes only. The use of Google Lens OCR functionality must comply with Google's Terms of Service. The author of this project is not responsible for any misuse of this software or for any consequences arising from its use. Users are solely responsible for ensuring that their use of this software complies with all applicable laws and regulations.


pkgId: 5edf2291591efac7d48ab061a693a562e49c9ea8e7377dc04b53ea91b7d4de73
name: python-chrome-proxy
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: chrome remote debug proxy
url: https://pypi.org/project/chrome-proxy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrome-proxy-1.0.2-1.src.rpm
checksum_type: sha256
description:
  安装
  ```
  pip install chrome-proxy -U
  ```
  启动代理
  ```shell

  chrome-proxy

  chrome-proxy --headless
  ```
  使用
  ```python
  from selenium import webdriver

  options = webdriver.ChromeOptions()



  options.debugger_address = "192.168.100.156:9223"
  driver = webdriver.Chrome(options=options)
  driver.get("https://www.baidu.com")
  print(driver.title)

  ```


pkgId: 7015d648907a1667faa438e27402ffb3c7b7e3a9ead0eb634d2f93e597513cb4
name: python-chrome-version
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://pypi.org/project/chrome-version/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrome-version-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  Detect the version of Chrome installed on Windows, Linux, Mac. Cross-platform using Python, native OS detection.

description:
  <h1 align="center">
      <strong>Chrome Version</strong>
  </h1>
  <p align="center">
      <em>Get the version of Chrome installed on Windows, Linux, Mac. Cross-platform using Python, native OS detection, does not require Selenium.</em>
  </p>
  <p align="center">
      <a href="https://github.com/hasansezertasan/chrome-version" target="_blank">
          <img src="https://img.shields.io/github/last-commit/hasansezertasan/chrome-version" alt="Latest Commit">
      </a>
          <img src="https://img.shields.io/github/workflow/status/hasansezertasan/chrome-version/Test">
          <img src="https://img.shields.io/codecov/c/github/hasansezertasan/chrome-version">
      <br />
      <a href="https://pypi.org/project/chrome-version" target="_blank">
          <img src="https://img.shields.io/pypi/v/chrome-version" alt="Package version">
      </a>
      <a href="https://pypi.org/project/chrome-version" target="_blank">
          <img src="https://img.shields.io/pypi/pyversions/chrome-version">
      </a>
      <img src="https://img.shields.io/github/license/hasansezertasan/chrome-version">
  </p>



  ``` bash
  pip install chrome-version
  ```



  Module:

  ```python
  >>> import chrome_version
  >>> print(chrome_version.get_chrome_version())
  >>> '103.0.5060.114'
  ```

  CLI:

  ```bash
  chrome-version
  103.0.5060.114
  ```



  At first,

  I needed to get the Chrome version for a project I was working on, which was using [Undetected Chromedriver](https://github.com/ultrafunkamsterdam/undetected-chromedriver). I found the gist below.

  When I used it in a variaty of projects, I decided to turn it into a module so I'll be free of copy/paste. It only have one functionality: getting the chrome version.

  Then,

  I decided to use it to learn more about:

  - Using [Poetry](https://python-poetry.org/) for packaging and dependency management.
  - Using scripts for CLI.
  - Versioning.
  - License management.
  - Documentation.
  - Publishing a module on PyPI.
  - Using GitHub Actions to automate the publishing process.
  - ...

  Finally,

  Now it's kind of a playground for me to learn more...



  - It might be useful for someone.
  - It's easier to pip install a module than copy/paste a gist.
  - Educational Purposes: A simple module is a good practice for me to learn how to build modules and publish them on PyPI and show others how easy it is.



  Based on [chrome-version](https://gist.github.com/primaryobjects/d5346bf7a173dbded1a70375ff7461b4) by [Kory Becker](https://github.com/primaryobjects).

  This package provides a CLI wrapper for the original project. All credit reserved to the author of the original code.


pkgId: 57a77e8fadc36b514e3e8edbabfe2a88032641161bf55c4b2a0a10fc9a6bdc00
name: python-chromedriver-auto
arch: src
version: 1.0.12
epoch: 0
release: 1
url: https://github.com/pypa/sampleproject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromedriver-auto-1.0.12-1.src.rpm
checksum_type: sha256
summary:
  This package downloads and helps you use chromedriver without needing to keep chromedriver updated regularly. Works for version no: 115.XX.XX.X and upwords.

description:
  Windows
  ```
  py -m pip install --upgrade pip
  ```

  Linux/MAC OS
  ```
  python3 -m pip install --upgrade pip
  ```


  ```
  pip install chromedriver-auto

  or

  pip3 install chromedriver-auto
  ```


  Recently(24 july 2023) Google has published a new website for providing chromedriver for newer versions of CHROME BROWSER.
  Details: https://googlechromelabs.github.io/chrome-for-testing/

  first it checks, if a chromedriver is already there or not. If no chromedriver or version miss-match found, it will download chromedriver automatically from the official website.

  Use Code:


  ```
  from chromedriver_auto.driver_ready import *
  driver.get('https://www.google.com')
  ```


pkgId: b751cab07de2fbd09d612749cc188c946c8764ded74c4e414cb5fabdab3015cb
name: python-chromedriver-autoinstaller
arch: src
version: 0.6.4
epoch: 0
release: 1
summary: Automatically install chromedriver that supports the currently installed version of chrome.
url: https://github.com/yeongbin-jo/python-chromedriver-autoinstaller
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromedriver-autoinstaller-0.6.4-1.src.rpm
checksum_type: sha256
description:
  Automatically download and install [chromedriver](https://chromedriver.chromium.org/) that supports the currently installed version of chrome. This installer supports Linux, MacOS and Windows operating systems.



  ```bash
  pip install chromedriver-autoinstaller
  ```


  Just type `import chromedriver_autoinstaller` in the module you want to use chromedriver.


  ```
  from selenium import webdriver
  import chromedriver_autoinstaller


  chromedriver_autoinstaller.install()  # Check if the current version of chromedriver exists
                                        
                                        

  driver = webdriver.Chrome()
  driver.get("http://www.python.org")
  assert "Python" in driver.title
  ```



  - CHIDA <[iam.yeongbin.jo@gmail.com](mailto:iam.yeongbin.jo@gmail.com)>
  - shawnCaza <[theshawn@gmail.com](mailto:theshawn@gmail.com)>


pkgId: 498a9465806bc9280788c03979239b3f4aa4eba4ca01c6858c7c4b921c990563
name: python-chromedriver-autoinstaller-fix
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Automatically install chromedriver that supports the currently installed version of chrome.
url: https://github.com/omkarcloud/chromedriver-autoinstaller-fix
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromedriver-autoinstaller-fix-1.0.6-1.src.rpm
checksum_type: sha256
description:
  For the [botasaurus](https://github.com/omkarcloud/botasaurus) project, we utilize a modified version of [python-chromedriver-autoinstaller](https://github.com/yeongbin-jo/python-chromedriver-autoinstaller) that includes a few bug fixes:

  - Correction of an `urllib3` error.
  - Improvement in Chromedriver version detection for Windows.



  ```bash
  pip install chromedriver-autoinstaller-fix
  ```


  Just type `import chromedriver_autoinstaller_fix` in the module you want to use chromedriver.


  ```
  from selenium import webdriver
  import chromedriver_autoinstaller_fix


  chromedriver_autoinstaller_fix.install()  # Check if the current version of chromedriver exists
                                        
                                        

  driver = webdriver.Chrome()
  driver.get("http://www.python.org")
  assert "Python" in driver.title
  ```


pkgId: ba714de683c94b6cea6652a4b8f29ce6a3e7ff47b23339f4d383bb0371e61427
name: python-chromedriver-autoupdater
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: Automatically install chromedriver that supports the currently installed version of chrome.
url: https://github.com/shawnCaza/python-chromedriver-autoinstaller
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromedriver-autoupdater-0.6.5-1.src.rpm
checksum_type: sha256
description:
  Automatically download and install [chromedriver](https://chromedriver.chromium.org/) that supports the currently installed version of chrome. This installer supports Linux, MacOS and Windows operating systems.

  Forked from [chromedriver-autoinstaller](https://github.com/yeongbin-jo/python-chromedriver-autoinstaller)



  ```bash
  pip install chromedriver_autoupdater
  ```


  Just type `import chromedriver_autoupdater` in the module you want to use chromedriver.


  ```
  from selenium import webdriver
  import chromedriver_autoupdater


  chromedriver_autoupdater.install()  # Check if the current version of chromedriver exists
                                        
                                        

  driver = webdriver.Chrome()
  driver.get("http://www.python.org")
  assert "Python" in driver.title
  ```


pkgId: 270e2e215ce460c2a0b3eb24c0986494e50dfef1478f3689eb6baaeac12a5028
name: python-chromeless
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Serverless selenium which dynamically execute any given code.
url: https://github.com/umihico/pythonista-chromeless
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromeless-0.9.1-1.src.rpm
checksum_type: sha256
description:
  AWS lambda with selenium & python is powerful solution.
  Let's access this benefit easily!

  - Don't create lambda functions every time. Just create this once.
  - Write the method.
  - Selenium dynamically execute your script.



  ```python

  def get_title(self, url):
      self.get(url)
      return self.title


  from chromeless import Chromeless
  chrome = Chromeless()
  chrome.attach(get_title)
  print(chrome.get_title("https://google.com")) # Returns Google
  ```


  You can also provide boto3 session object if you don't want to use default aws profile:
  ```python
  from chromeless import Chromeless
  from boto3.session import Session

  session = Session(aws_access_key_id='<YOUR ACCESS KEY ID>',
                    aws_secret_access_key='<YOUR SECRET KEY>',
                    region_name='<REGION NAME>')

  session = Session(profile_name='<YOUR_PROFILE_NAME>')
  chrome = Chromeless(boto3_session=session)
  ```

  Or also you can just set appropriate environment vars works with boto3,
   so it will auto detect your choice e.g.:
  ```

  export AWS_DEFAULT_REGION=<your aws region>


  set AWS_DEFAULT_REGION=<your aws region>
  ```



  - `git clone --depth 1 https://github.com/umihico/pythonista-chromeless.git chromeless && cd $_`
  - `sls deploy --region YOUR_REGION`
  - `pip install chromeless`

  That's it! Now run the `example.py` and confirm your selenium works in lambda functions!



  - **Don't call selenium native methods directly.** Solution is wrapping.

  ```python

  chrome = Chromeless()
  chrome.get("https://google.com") # Not a attached method. AttributeError will be raised.
  chrome.title # Same. AttributeError.


  def wrapper(self, url):
      self.get(url)
      return self.title

  chrome = Chromeless()
  chrome.attach(wrapper)
  print(chrome.wrapper("https://google.com")) # prints 'Google'.
  print(chrome.wrapper("https://microsoft.com")) # But you can execute as many times as you want.
  print(chrome.wrapper("https://apple.com")) # Arguments are adjustable each time.
  ```

  - Multiple methods are also attachable.

  ```python
  def login(self):
      self.get("https://example.com/login")
      self.find_element_by_id("username").send_keys("umihico")
      self.find_element_by_id("password").send_keys("password")
      self.find_element_by_name("submit").click()

  def test1(self):
      self.login()
      self.get("https://example.com/")

  def test2(self):
      self.login()
      self.get("https://example.com/logout")

  chrome = Chromeless()
  chrome.attach(login) # You can attach multiple methods too.
  chrome.attach(test1) # It means you can also refactor the common code.
  chrome.attach(test2)
  print(chrome.test1())
  print(chrome.test2())
  ```

  - To screenshot

  ```python

  def bad_wrapper(self):
    self.get("https://google.com")
    self.save_screenshot("screenshot.png")
    


  def good_wrapper(self):
    self.get("https://google.com")
    return self.get_screenshot_as_png()
    

  chrome = Chromeless()
  chrome.attach(good_wrapper)
  png = chrome.good_wrapper()

  with open("screenshot.png", 'wb') as f:
      f.write(png)

  ```



  The project is licensed under the MIT license.


pkgId: b61b443dec7324111d99cf2d897656f9dd598ed0f253e14fe5274debebc76fe9
name: python-chrometrace
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A Python library for Chrome Trace Viewer files
url: https://github.com/jonasehrlich/chrometrace
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrometrace-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A Python library for creating Chrome Trace Viewer files. The Chrome Trace Viewer can be opened in
  Chromium-based browsers (e.g. Google Chrome, Microsoft Edge, Chromium, ...) by entering _chrome://tracing_ into the
  address bar.

  The trace event format and types are defined in
  [this document](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU).



  Install the package from PyPi using the following command.

  ```sh
  pip install chrometrace
  ```



  ```python
  import chrometrace


  with chrometrace.TraceSink("trace.json") as trace_sink:
      
      myapp_tracer = trace_sink.process_tracer("myapp", process_id=1337)
      
      renderer_thread_tracer = myapp_tracer.thread_tracer("RendererThread", 1)

      
      renderer_thread_tracer.complete("my_function", timestamp_us=10, duration_us=1000)
  ```



  Currently only the _JSON Array Format_ is supported due to its simplicity. Support for the _JSON Object Format_ might be
  added in the future.



  * [x] Duration Events
    * Begin
    * End
  * [x] Complete Events
  * [x] Instant Events
    * With different scopes
  * [x] Counter Events
  * [ ] Async Events
  * [ ] Flow Events
  * [x] Metadata Events
    * Name process / thread
    * Define process / thread sort index
    * Process labels
  * [ ] Sample Events
  * [ ] Object Events
  * [ ] Mark Events
  * [ ] Clock Sync Events
  * [ ] Context Events


pkgId: 059fba229d121db1af088fdc475ab4e24fe447b9d38b7db628b9a3569f4f96f7
name: python-chromie
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: A simple utility CLI tool for packaging and maintaining chrome extensions.
url: https://github.com/Sandersland/chromie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromie-0.3.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://user-images.githubusercontent.com/17189382/90958771-81935380-e464-11ea-8cfa-ecf8b608802e.png" width="200"/></p>

  <h3 align="center">CHROMIE</h3>
  <p align="center">A simple utility CLI for packaging and maintaining chrome extensions.</p>


  ```bash
  pip install chromie
  ```



  ```bash
  chromie init
  >> What is the name of your project?
  hello world
  ```

  results:
  ```text
  hello world/
  ├── dist/
  │   └── web store/
  ├── src/
  │   ├── images/
  │   └── manifest.json
  └── .zipignore
  ```

  `chromie init -n "hello world"`


  ```bash
  cd hello world
  chromie pack
  >> How would you like to increment the version?
  >> Options are either 'major', 'minor', or 'patch':
  patch
  ```

  results:
  ```text
  hello world/
  ├── dist/
  │   ├── web store/
  │   └── hello world-0.0.1.zip
  ├── src/
  │   ├── images/
  │   └── manifest.json
  └── .zipignore
  ```



  `chromie pack -i major`

  `chromie pack -v 1.0.0`


  `chromie config email hello@world.com`
  ```text
  hello world/.chromie/settings.json
  {
    "email": "hello@world.com"
  }
  ```


  The following requires that the .chromie/settings.json file includes email, client_email, client_id, and private_key for authentication.
  ```text
  hello world/.chromie/settings.json
  {
    "email": "hello@world.com",
    "client_email": "",
    "private_key": ""
  }
  ```

  `chromie upload`


  `chromie update`


  `chromie publish`


  The MIT License (MIT)

  Copyright (c) 2020 Steffen Andersland

  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: a6ee508866ffc39e0500b3e66924231931cf21f6c548ab337877fedf997e1920
name: python-chromophile
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Color maps for continuous quantitative data
url: https://github.com/kylehofmann/chromophile_dev
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chromophile-1.0.6-1.src.rpm
checksum_type: sha256
description:
  The Chromophile color maps are designed for the accurate display
  of quantitative data.  This package contains the Chromophile
  color maps in both `Matplotlib <https://matplotlib.org/>`_ and
  `Bokeh <https://bokeh.org/>`_ formats.

rpm_license:
  Creative Commons Legal Code  CC0 1.0 Universal  CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER.  Statement of Purpose  The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").  Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.  For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.  1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:  i. the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work; ii. moral rights retained by the original author(s) and/or performer(s); iii. publicity and privacy rights pertaining to a person's image or likeness depicted in a Work; iv. rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below; v. rights protecting the extraction, dissemination, use and reuse of data in a Work; vi. database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and vii. other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.  2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.  3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.  4. Limitations and Disclaimers.  a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document. b. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law. c. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work. d. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.


pkgId: 28a653086d6edd567af5b2850d90953c1d138e6461d8811101e12ea873c78f1e
name: python-chronify
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Time series store and mapping libray
url: https://pypi.org/project/chronify/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronify-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/docs-ready-blue.svg)](https://nrel.github.io/chronify)
  [![codecov](https://codecov.io/gh/nrel/chronify/graph/badge.svg?token=WIY2KAOX63)](https://codecov.io/gh/nrel/chronify)


  This package implements a store for time series data in support of Python-based
  modeling packages. It supports validation and mapping across different time configurations.


  🚧


  ```
  $ pip install chronify
  ```


  ```
  $ pip install -e ".[dev]"
  ```

  Please install `pre-commit` so that your code is checked before making commits.
  ```
  $ pre-commit install
  ```


  chronify is developed under NREL Software Record SWR-21-52, "demand-side grid model".
  [License](https://github.com/NREL/chronify/blob/main/LICENSE).


pkgId: e6938926d820923b860a8957745d886a969804ddf689ff009d459fa88d285d41
name: python-chrono24
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: chrono24
url: https://github.com/irahorecka/chrono24
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrono24-0.3.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://static.chrono24.com/images/default/logo-positive-reduced.svg" width="50%" />
  </p>

  <br>

  [Chrono24](https://www.chrono24.com/) API wrapper

  [![pypiv](https://img.shields.io/pypi/v/chrono24.svg)](https://pypi.python.org/pypi/chrono24)
  [![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
  [![continuous-integration](https://github.com/irahorecka/chrono24/workflows/continuous-integration/badge.svg)](https://github.com/irahorecka/chrono24/actions)
  [![Licence](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/irahorecka/chrono24/main/LICENSE)



  ```bash
  pip install chrono24
  ```



  Perform a standard search for Rolex DateJust watches:

  ```python
  import chrono24

  for listing in chrono24.query("Rolex DateJust").search():
      print(listing)
  ```

  Example output:

  ```python
  >>> {'id': '32322343',
      'url': 'https://chrono24.com/rolex/datejust-41mm-blue-diamond-dial-2022---126334--id32322343.htm',
      'manufacturer': 'Rolex',
      'certification_status': 'Basic',
      'title': 'Rolex Datejust 41',
      'description': '41mm Blue Diamond Dial 2022 - 126334',
      'price': '$16,553',
      'shipping_price': '$396',
      'location': 'Düsseldorf, Germany.',
      'merchant_name': 'Dealer',
      'badge': 'Professional',
      'image_urls': ['https://cdn2.chrono24.com/images/uhren/32322343-gp8hzm4ppkzsbhzc7s7bl2vh-ExtraLarge.jpg',
      'https://cdn2.chrono24.com/images/uhren/32322343-u7wq78hxqoalnfrlag1gkt8d-ExtraLarge.jpg',
      'https://cdn2.chrono24.com/images/uhren/32322343-93ykurb99s654x7aysnh8ljs-ExtraLarge.jpg',
      'https://cdn2.chrono24.com/images/uhren/32322343-gxd85po61ynmoictprm1gvfq-ExtraLarge.jpg',
      'https://cdn2.chrono24.com/images/uhren/32322343-den0sntpacmucq5zdktzul70-ExtraLarge.jpg']}
      
  ```



  Search for standard or detailed watch listings for any query, limiting results to, for example, 25 listings. All results will be retrieved if no limit is provided, and they'll be sorted by new listings first.

  ```python
  import chrono24

  rolex_dj = chrono24.query("Rolex DateJust")


  for listing in rolex_dj.search(limit=25):
      print(listing)


  for detailed_listing in rolex_dj.detailed_search(limit=25):
      print(detailed_listing)
  ```

  **Note:** When using these functions, be cautious not to overwhelm Chrono24 with excessive requests. The `standard_search` method consumes 1 request per 120 posts retrieved, while `detailed_search` utilizes 1 request per individual post. Avoid flooding requests to maintain a balanced usage of the Chrono24 service and prevent any potential access limitations.



  Example output from `.search`:

  ```python
  {
      'id': '32322343',
      'url': 'https://chrono24.com/rolex/datejust-41mm-blue-diamond-dial-2022---126334--id32322343.htm',
      'manufacturer': 'Rolex',
      'certification_status': 'Basic',
      'title': 'Rolex Datejust 41',
      'description': '41mm Blue Diamond Dial 2022 - 126334',
      'price': '$16,553',
      'shipping_price': '$396',
      'location': 'Düsseldorf, Germany.',
      'merchant_name': 'Dealer',
      'badge': 'Professional',
      'image_urls': [...],  # List of image URLs
  }
  ```

  Example output from `.detailed_search`, which extends results from `.search`:

  ```python
  {
      'id': '32322343',
      'url': 'https://chrono24.com/rolex/datejust-41mm-blue-diamond-dial-2022---126334--id32322343.htm',
      'manufacturer': 'Rolex',
      'certification_status': 'Basic',
      'title': 'Rolex Datejust 41',
      'description': '41mm Blue Diamond Dial 2022 - 126334',
      'price': '$16,553',
      'shipping_price': '$396',
      'location': 'Düsseldorf, Germany.',
      'merchant_name': 'Dealer',
      'badge': 'Professional',
      'image_urls': [...],  # List of image URLs
      'listing_code': 'J8S2V6',
      'brand': 'Rolex',
      'model': 'Datejust 41',
      'reference_number': '126334',
      'dealer_product_code': '8675310109006',
      'case_material': 'Steel',
      'bracelet_material': 'Steel',
      'year_of_production': '2022',
      'condition': 'Very good (Worn with little to no signs of wear)',
      'scope_of_delivery': 'Original box, original papers',
      'availability': 'Item needs to be procured',
      'case_diameter': '41 mm',
      'bracelet_color': 'Steel',
      'availabe_payments': [...],  # List of available payment methods
      'anticipated_delivery': 'Latest anticipated delivery on 1/22',
      'merchant_rating': '4.4',
      'merchant_reviews': '196',
      'merchant_badges': [...],  # List of merchant badges
  }
  ```

  **Note:** Output keys in `.search` will always be constant, but `.detailed_search` can vary based on information provided by the listing page, expanding on the details retrieved by `.search`.



  You can refine your watch searches using various filter criteria, as well as define year ranges using `min_year` and `max_year`. Pre-defined filters include options such as case material, bracelet type, movement type, and more. These filters and year constraints can be applied when creating a query object.



  To use filters, specify them when creating a query using the `filters` argument. You can pass a single string, a list/tuple of filter keys, or include year constraints using the `min_year` and `max_year` parameters:

  ```python
  import chrono24


  steel_rolex_dj = chrono24.query("Rolex DateJust", filters="steel")

  steel_auto_rolex_dj = chrono24.query("Rolex DateJust", filters=["steel", "automatic"])

  new_rolex_dj = chrono24.query("Rolex DateJust", min_year=2010, max_year=2020)

  new_steel_auto_rolex_dj = chrono24.query("Rolex DateJust", filters=["steel", "automatic"], min_year=2010, max_year=2020)
  ```



  The available filter categories are:

  - **Case Filters**: Material, diameter, and more.
  - **Clasp Filters**: Clasp type, material, etc.
  - **Condition and Delivery Contents**: Item condition, delivery options, included papers/box.
  - **Dial Filters**: Dial color, numerals, etc.
  - **Location Filters**: Country-specific filters.
  - **Movement and Functions**: Manual, automatic, complications.
  - **Other Filters**: Miscellaneous filters such as water resistance, glass type.
  - **Seller and Listing Type**: Dealer, private seller, new/used.
  - **Sort By**: Sorting options like 'Newest listings first', 'Price ascending', etc.
  - **Strap and Bracelet**: Bracelet material, color, strap type.
  - **Watch Type**: Sports, dress, luxury, and more.



  You can view all available filters using the `chrono24.filters.show()` method:

  ```python
  import chrono24


  chrono24.filters.show()
  ```

  This will print a categorized list of all possible filters, helping you decide which ones to apply to your query. If you're not sure which filter to use, you can also search for filter keys using the `chrono24.filters.search(query)` method:

  ```python
  import chrono24


  chrono24.filters.search("steel")
  ```

  Example output:

  ```text
  Search results for query 'steel':

  Direct matches:
    - gold_steel_band
    - steel_band
    - gold_steel_color
    - steel_band_color
    - gold_steel_clasp
    - steel_clasp
    - gold_steel
    - steel
    - gold_steel_bezel
    - steel_bezel

  Fuzzy matches:
    - steel
    - steel_band
    - gold_steel
    - steel_clasp
    - steel_bezel
  ```

  This output shows the best filter keys matching the query 'steel', divided into **Direct matches** (exact or close matches) and **Fuzzy matches** (similar but not exact matches). Use these filter keys to refine your watch search in `chrono24`.



  The `chrono24` instance offers public attributes:

  - `count`: Total number of listings found.
  - `url`: URL of listings page.

  ```python
  import chrono24

  rolex_dj = chrono24.query("Rolex DateJust")

  rolex_dj.count

  rolex_dj.url

  ```



  The `chrono24` package handles specific exceptions that might occur during its use:

  - `NoListingsFoundException`: Raised when no listings are found.
  - `RequestException`: Raised when a request error occurs or repeated requests fail.

  ```python
  import chrono24
  from chrono24.exceptions import NoListingsFoundException, RequestException

  try:
      invalid_query = chrono24.query("Invalid Query")
  except NoListingsFoundException:
      
      print("No listings were found.")
  except RequestException:
      
      print("Request error or repeated requests failed.")
  ```



  - [Issues Tracker](https://github.com/irahorecka/chrono24/issues)
  - [Source Code](https://github.com/irahorecka/chrono24/tree/main/chrono24)



  If you are having issues or would like to propose a new feature, please use the [issues tracker](https://github.com/irahorecka/chrono24/issues).



  This project is licensed under the MIT license.


pkgId: 972f431dd8968898d0801a93c3ad87ac787e0cbda1c63d3736a66ebfb8f5338a
name: python-chronometry
arch: src
version: 2020.11.12
epoch: 0
release: 1
summary: Python library for tracking time and displaying progress bars
url: https://github.com/idin/chronometry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronometry-2020.11.12-1.src.rpm
checksum_type: sha256
description:
  `Estimator` is an object that estimates the running time of a single argument function.
  You can use it to avoid running a script for too long.
  For example, if you want to cluster a large dataset and running it might take too long,
  and cost too much if you use cloud computing,
  you can create a function with one argument `x` which takes a sample with `x` rows
  and clusters it; then you can use `Estimator` to estimate how long it takes to run it
  on the full dataset by providing the actual number of rows to the `estimate()` method.

  `Estimator` uses a *Polynomial* *Linear Regression* model
  and gives more weight to larger numbers for the training.



  ```python
  from chronometry import Estimator
  from time import sleep

  def multiply_with_no_delay(x, y):
      return (x ** 2 + 0.1 * x ** 3 + 1) * 0.00001 + y * 0.001

  def multiply(x, y):
      sleep_time = multiply_with_no_delay(x, y)
      if sleep_time > 30:
          raise
      sleep(sleep_time)
      if y == 6:
          sleep(12)
      elif 7 < y < 15:
          raise Exception()
      return sleep_time

  estimator = Estimator(function=multiply, polynomial_degree=3, timeout=5)


  estimator.auto_explore()
  estimator.predict_time(x=10000, y=10000)
  ```
  The above code runs for about *53* seconds and then estimates that
  `multiply(10000, 10000)` will take *1002371.7* seconds which is only slightly
  smaller than the correct number: *1001010* seconds.

  `max_time` is the maximum time allowed for the estimate function to run.

  If you are using `Estimator` in *Jupyter*,
  you can plot the measurements with the `plot()` method (no arguments needed) which
  returns a `matplotlib` `AxesSubplot` object and displays it at the same time.

  ```python
  estimator.plot('x')

  estimator.plot('y')
  ```


pkgId: b7c0f9b2460c6e77637ab8f56784f39b72a1bc0fd7345f581af285517481a9a1
name: python-chronos-cli
arch: src
version: 0.2.12
epoch: 0
release: 1
summary: A CLI tool that infers a next version number for Git repos.
url: https://github.com/devoperate/chronos
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronos-cli-0.2.12-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/chronos-cli.svg)](https://pypi.python.org/pypi/chronos-cli)
  [![pypi python versions](https://img.shields.io/pypi/pyversions/chronos-cli.svg)](https://pypi.python.org/pypi/chronos-cli)
  [![pipeline status](https://gitlab.com/devoperate/chronos/badges/master/pipeline.svg)](https://gitlab.com/devoperate/chronos/commits/master)
  [![Documentation Status](https://readthedocs.org/projects/chronos-cli/badge/?version=latest)](https://chronos-cli.readthedocs.io/en/latest/?badge=latest)
  ![sonarcloud quality gate](https://sonarcloud.io/api/project_badges/measure?project=devoperate_chronos&metric=alert_status)
  ![sonarcloud coverage](https://sonarcloud.io/api/project_badges/measure?project=devoperate_chronos&metric=coverage)
  ![sonarcloud bugs](https://sonarcloud.io/api/project_badges/measure?project=devoperate_chronos&metric=bugs)
  ![sonarcloud reliability](https://sonarcloud.io/api/project_badges/measure?project=devoperate_chronos&metric=reliability_rating)

  A CLI tool that infers a next version number for Git repos. It does its magic by looking at the commit messages of commits made since the last tag that had a [semver](https://semver.org) in it. For this to work properly, your commits should following the [Conventional Commits](https://conventionalcommits.org) spec.



  **Requires Git 2.0+.**

  To use the tool:

  - `pip install --upgrade chronos-cli`
  - Change into a Git repo.
  - `chronos infer`

  To bootstrap a development environment (after you've cloned the repo and changed into it):

  - `pip install --upgrade pipenv`
  - `pipenv sync --dev`



  Docs are hosted at https://chronos-cli.readthedocs.io.



  This project follows [PEP8](https://www.python.org/dev/peps/pep-0008/).



  - `pytest` will run unit tests in this repo.
  - `flake8` will lint the code.

  This repo also has a CI/CD pipeline built with [Ansible](https://ansible.com) and [GitLab CI](https://about.gitlab.com/product/continuous-integration/).

  The pipeline's Ansible playbook can be run on your *nix workstation too:

  ```sh
  ansible-playbook ansible/pipeline.yml --tags build
  ```



  Commits should follow the [Conventional Commits](https://conventionalcommits.org) spec.



  TODO



  - Thanks to [Eric Poitras](https://github.com/eric-poitras) for asking me to write an earlier version of what would become this tool. This was really his idea.


pkgId: 4e8f1b5fb244be52e7d87a1bfb5c6eafb8a445d02a77ee0f547974f339b682b7
name: python-chronos-forecasting
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Chronos: Pretrained models for time series forecasting
url: https://github.com/amazon-science/chronos-forecasting
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronos-forecasting-1.3.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="figures/chronos-logo.png" width="60%">
  </div>


  <div align="center">



  [![preprint](https://img.shields.io/static/v1?label=arXiv&message=2403.07815&color=B31B1B&logo=arXiv)](https://arxiv.org/abs/2403.07815)
  [![huggingface](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Datasets-FFD21E)](https://huggingface.co/datasets/autogluon/chronos_datasets)
  [![huggingface](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models-FFD21E)](https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444)
  [![faq](https://img.shields.io/badge/FAQ-Questions%3F-blue)](https://github.com/amazon-science/chronos-forecasting/issues?q=is%3Aissue+label%3AFAQ)
  [![License: MIT](https://img.shields.io/badge/License-Apache--2.0-green.svg)](https://opensource.org/licenses/Apache-2.0)

  </div>



  - **26 Nov 2024**: ⚡️ Chronos-Bolt models released [on HuggingFace](https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444). Chronos-Bolt models are more accurate (5% lower error), up to 250x faster and 20x more memory efficient than the original Chronos models of the same size!
  - **27 Jun 2024**: 🚀 [Released datasets](https://huggingface.co/datasets/autogluon/chronos_datasets) used in the paper and an [evaluation script](./scripts/README.md#evaluating-chronos-models) to compute the WQL and MASE scores reported in the paper.
  - **17 May 2024**: 🐛 Fixed an off-by-one error in bin indices in the `output_transform`. This simple fix significantly improves the overall performance of Chronos. We will update the results in the next revision on ArXiv.
  - **10 May 2024**: 🚀 We added the code for pretraining and fine-tuning Chronos models. You can find it in [this folder](./scripts/training). We also added [a script](./scripts/kernel-synth.py) for generating synthetic time series data from Gaussian processes (KernelSynth; see Section 4.2 in the paper for details). Check out the [usage examples](./scripts/).
  - **19 Apr 2024**: 🚀 Chronos is now supported on [AutoGluon-TimeSeries](https://auto.gluon.ai/stable/tutorials/timeseries/index.html), the powerful AutoML package for time series forecasting which enables model ensembles, cloud deployments, and much more. Get started with the [tutorial](https://auto.gluon.ai/stable/tutorials/timeseries/forecasting-chronos.html).
  - **08 Apr 2024**: 🧪 Experimental [MLX inference support](https://github.com/amazon-science/chronos-forecasting/tree/mlx) added. If you have an Apple Silicon Mac, you can now obtain significantly faster forecasts from Chronos compared to CPU inference. This provides an alternative way to exploit the GPU on your Apple Silicon Macs together with the "mps" support in PyTorch.
  - **25 Mar 2024**: 🚀 [v1.1.0 released](https://github.com/amazon-science/chronos-forecasting/releases/tag/v1.1.0) with inference optimizations and `pipeline.embed` to extract encoder embeddings from Chronos.
  - **13 Mar 2024**: 🚀 Chronos [paper](https://arxiv.org/abs/2403.07815) and inference code released.



  Chronos is a family of **pretrained time series forecasting models** based on language model architectures. A time series is transformed into a sequence of tokens via scaling and quantization, and a language model is trained on these tokens using the cross-entropy loss. Once trained, probabilistic forecasts are obtained by sampling multiple future trajectories given the historical context. Chronos models have been trained on a large corpus of publicly available time series data, as well as synthetic data generated using Gaussian processes.

  For details on Chronos models, training data and procedures, and experimental results, please refer to the paper [Chronos: Learning the Language of Time Series](https://arxiv.org/abs/2403.07815).

  <p align="center">
    <img src="figures/main-figure.png" width="100%">
    <br />
    <span>
      Fig. 1: High-level depiction of Chronos. (<b>Left</b>) The input time series is scaled and quantized to obtain a sequence of tokens. (<b>Center</b>) The tokens are fed into a language model which may either be an encoder-decoder or a decoder-only model. The model is trained using the cross-entropy loss. (<b>Right</b>) During inference, we autoregressively sample tokens from the model and map them back to numerical values. Multiple trajectories are sampled to obtain a predictive distribution.
    </span>
  </p>



  The models in this repository are based on the [T5 architecture](https://arxiv.org/abs/1910.10683). The only difference is in the vocabulary size: Chronos-T5 models use 4096 different tokens, compared to 32128 of the original T5 models, resulting in fewer parameters.

  <div align="center">

  | Model                                                                  | Parameters | Based on                                                               |
  | ---------------------------------------------------------------------- | ---------- | ---------------------------------------------------------------------- |
  | [**chronos-t5-tiny**](https://huggingface.co/amazon/chronos-t5-tiny)   | 8M         | [t5-efficient-tiny](https://huggingface.co/google/t5-efficient-tiny)   |
  | [**chronos-t5-mini**](https://huggingface.co/amazon/chronos-t5-mini)   | 20M        | [t5-efficient-mini](https://huggingface.co/google/t5-efficient-mini)   |
  | [**chronos-t5-small**](https://huggingface.co/amazon/chronos-t5-small) | 46M        | [t5-efficient-small](https://huggingface.co/google/t5-efficient-small) |
  | [**chronos-t5-base**](https://huggingface.co/amazon/chronos-t5-base)   | 200M       | [t5-efficient-base](https://huggingface.co/google/t5-efficient-base)   |
  | [**chronos-t5-large**](https://huggingface.co/amazon/chronos-t5-large) | 710M       | [t5-efficient-large](https://huggingface.co/google/t5-efficient-large) |
  | [**chronos-bolt-tiny**](https://huggingface.co/amazon/chronos-bolt-tiny)   | 9M         | [t5-efficient-tiny](https://huggingface.co/google/t5-efficient-tiny)   |
  | [**chronos-bolt-mini**](https://huggingface.co/amazon/chronos-bolt-mini)   | 21M        | [t5-efficient-mini](https://huggingface.co/google/t5-efficient-mini)   |
  | [**chronos-bolt-small**](https://huggingface.co/amazon/chronos-bolt-small) | 48M        | [t5-efficient-small](https://huggingface.co/google/t5-efficient-small) |
  | [**chronos-bolt-base**](https://huggingface.co/amazon/chronos-bolt-base)   | 205M       | [t5-efficient-base](https://huggingface.co/google/t5-efficient-base)   |

  </div>



  The following figure showcases the remarkable **zero-shot** performance of Chronos and Chronos-Bolt models on 27 datasets against local models, task-specific models and other pretrained models. For details on the evaluation setup and other results, please refer to [the paper](https://arxiv.org/abs/2403.07815).

  <p align="center">
    <img src="figures/zero_shot-agg_scaled_score.svg" width="100%">
    <br />
    <span>
      Fig. 2: Performance of different models on Benchmark II, comprising 27 datasets <b>not seen</b> by Chronos and Chronos-Bolt models during training. This benchmark provides insights into the zero-shot performance of Chronos and Chronos-Bolt models against local statistical models, which fit parameters individually for each time series, task-specific models <i>trained on each task</i>, and pretrained models trained on a large corpus of time series. Pretrained Models (Other) indicates that some (or all) of the datasets in Benchmark II may have been in the training corpus of these models. The probabilistic (WQL) and point (MASE) forecasting metrics were normalized using the scores of the Seasonal Naive baseline and aggregated through a geometric mean to obtain the Agg. Relative WQL and MASE, respectively.
    </span>
  </p>



  To perform inference with Chronos or Chronos-Bolt models, the easiest way is to install this package through `pip`:

  ```sh
  pip install chronos-forecasting
  ```

  If you're interested in pretraining, fine-tuning, and other research & development, clone and install the package from source:

  ```sh

  git clone https://github.com/amazon-science/chronos-forecasting.git


  pip install --editable ".[training]"
  ```

  > [!TIP]
  > This repository is intended for research purposes and provides a minimal interface to Chronos models. The recommended way of using Chronos for production use cases is through [AutoGluon](https://auto.gluon.ai), which features effortless fine-tuning, augmenting Chronos models with exogenous information through covariate regressors, ensembling with other statistical and machine learning models, as well as seamless deployments on AWS with SageMaker 🧠. Check out the AutoGluon Chronos [tutorial](https://auto.gluon.ai/stable/tutorials/timeseries/forecasting-chronos.html).



  A minimal example showing how to perform forecasting using Chronos and Chronos-Bolt models:

  ```python
  import pandas as pd  # requires: pip install pandas
  import torch
  from chronos import BaseChronosPipeline

  pipeline = BaseChronosPipeline.from_pretrained(
      "amazon/chronos-t5-small",  # use "amazon/chronos-bolt-small" for the corresponding Chronos-Bolt model
      device_map="cuda",  # use "cpu" for CPU inference and "mps" for Apple Silicon
      torch_dtype=torch.bfloat16,
  )

  df = pd.read_csv(
      "https://raw.githubusercontent.com/AileenNielsen/TimeSeriesAnalysisWithPython/master/data/AirPassengers.csv"
  )







  forecast = pipeline.predict(
      context=torch.tensor(df["#Passengers"]), prediction_length=12
  )
  ```

  More options for `pipeline.predict` can be found with:

  ```python
  from chronos import ChronosPipeline, ChronosBoltPipeline

  print(ChronosPipeline.predict.__doc__)  # for Chronos models
  print(ChronosBoltPipeline.predict.__doc__)  # for Chronos-Bolt models
  ```

  We can now visualize the forecast:

  ```python
  import matplotlib.pyplot as plt  # requires: pip install matplotlib
  import numpy as np

  forecast_index = range(len(df), len(df) + 12)
  low, median, high = np.quantile(forecast[0].numpy(), [0.1, 0.5, 0.9], axis=0)

  plt.figure(figsize=(8, 4))
  plt.plot(df["#Passengers"], color="royalblue", label="historical data")
  plt.plot(forecast_index, median, color="tomato", label="median forecast")
  plt.fill_between(forecast_index, low, high, color="tomato", alpha=0.3, label="80% prediction interval")
  plt.legend()
  plt.grid()
  plt.show()
  ```



  A minimal example showing how to extract encoder embeddings from Chronos models:

  ```python
  import pandas as pd
  import torch
  from chronos import ChronosPipeline

  pipeline = ChronosPipeline.from_pretrained(
      "amazon/chronos-t5-small",
      device_map="cuda",
      torch_dtype=torch.bfloat16,
  )

  df = pd.read_csv("https://raw.githubusercontent.com/AileenNielsen/TimeSeriesAnalysisWithPython/master/data/AirPassengers.csv")



  context = torch.tensor(df["#Passengers"])
  embeddings, tokenizer_state = pipeline.embed(context)
  ```



  Scripts for pretraining, fine-tuning and evaluating Chronos models can be found in [this folder](./scripts/).



  Datasets used in the Chronos paper for pretraining and evaluation (both in-domain and zero-shot) are available through the HuggingFace repos: [`autogluon/chronos_datasets`](https://huggingface.co/datasets/autogluon/chronos_datasets) and [`autogluon/chronos_datasets_extra`](https://huggingface.co/datasets/autogluon/chronos_datasets_extra). Check out these repos for instructions on how to download and use the datasets.



  - [Adapting language model architectures for time series forecasting](https://www.amazon.science/blog/adapting-language-model-architectures-for-time-series-forecasting) (Amazon Science blog post)
  - [Amazon AI Researchers Introduce Chronos: A New Machine Learning Framework for Pretrained Probabilistic Time Series Models](https://www.marktechpost.com/2024/03/15/amazon-ai-researchers-introduce-chronos-a-new-machine-learning-framework-for-pretrained-probabilistic-time-series-models/) (Marktechpost blog post)
  - [Chronos: The Rise of Foundation Models for Time Series Forecasting](https://towardsdatascience.com/chronos-the-rise-of-foundation-models-for-time-series-forecasting-aaeba62d9da3) (Towards Data Science blog post by Luís Roque and Rafael Guedes)
  - [Moirai: Time Series Foundation Models for Universal Forecasting](https://towardsdatascience.com/moirai-time-series-foundation-models-for-universal-forecasting-dc93f74b330f) (Towards Data Science blog post by Luís Roque and Rafael Guedes, includes comparison of Chronos with Moirai)
  - [Chronos: The Latest Time Series Forecasting Foundation Model by Amazon](https://towardsdatascience.com/chronos-the-latest-time-series-forecasting-foundation-model-by-amazon-2687d641705a) (Towards Data Science blog post by Marco Peixeiro)
    - The original article had a critical bug affecting the metric computation for Chronos. We opened a [pull request](https://github.com/marcopeix/time-series-analysis/pull/10) to fix it.
  - [How to Effectively Forecast Time Series with Amazon's New Time Series Forecasting Model](https://towardsdatascience.com/how-to-effectively-forecast-time-series-with-amazons-new-time-series-forecasting-model-9e04d4ccf67e) (Towards Data Science blog post by Eivind Kjosbakken)
  - [Chronos: Learning the Language of Time Series](https://minimizeregret.com/linked/2024/03/27/chronos-forecasting/) (Minimize Regret blog post by Tim Radtke)
  - [Chronos: Another Zero-Shot Time Series Forecaster LLM](https://levelup.gitconnected.com/chronos-another-zero-shot-time-series-forecaster-llm-0e80753a7ad0) (Level Up Coding blog post by Level Up Coding AI TutorMaster)
  - [Paper Review: Chronos: Learning the Language of Time Series](https://andlukyane.com/blog/paper-review-chronos) (Review by Andrey Lukyanenko)
  - [Foundation Models for Forecasting: the Future or Folly?](https://insights.radix.ai/blog/foundation-models-for-forecasting-the-future-or-folly) (Blog post by Radix)
  - [Learning the Language of Time Series with Chronos](https://medium.com/@ManueleCaddeo/learning-the-language-of-time-series-with-chronos-fea7d0fedde4) (Medium post by Manuele Caddeo)
  - [The latest advancement in Time Series Forecasting from AWS: Chronos](https://medium.com/chat-gpt-now-writes-all-my-articles/the-latest-advancement-in-time-series-forecasting-from-aws-chronos-python-code-included-0205d01248f3) (Medium post by Abish Pius)
  - [Decoding the Future: How Chronos Redefines Time Series Forecasting with the Art of Language](https://medium.com/@zamalbabar/decoding-the-future-how-chronos-redefines-time-series-forecasting-with-the-art-of-language-cecc2174e400) (Medium post by Zamal)
  - [Comparison of Chronos against the SCUM ensemble of statistical models](https://github.com/Nixtla/nixtla/tree/main/experiments/amazon-chronos) (Benchmark by Nixtla)
    - We opened a [pull request](https://github.com/Nixtla/nixtla/pull/281) extending the analysis to 28 datasets (200K+ time series) and showing that **zero-shot** Chronos models perform comparably to this strong ensemble of 4 statistical models while being significantly faster on average. Our complete response can be [found here](https://www.linkedin.com/pulse/extended-comparison-chronos-against-statistical-ensemble-ansari-4aste/).
  - [Comparison of Chronos against a variety of forecasting models](https://www.linkedin.com/feed/update/urn:li:activity:7178398371815051267/) (Benchmark by ReadyTensor)



  If you find Chronos models useful for your research, please consider citing the associated [paper](https://arxiv.org/abs/2403.07815):

  ```
  @article{ansari2024chronos,
      title={Chronos: Learning the Language of Time Series},
      author={Ansari, Abdul Fatir and Stella, Lorenzo and Turkmen, Caner and Zhang, Xiyuan, and Mercado, Pedro and Shen, Huibin and Shchur, Oleksandr and Rangapuram, Syama Syndar and Pineda Arango, Sebastian and Kapoor, Shubham and Zschiegner, Jasper and Maddix, Danielle C. and Mahoney, Michael W. and Torkkola, Kari and Gordon Wilson, Andrew and Bohlke-Schneider, Michael and Wang, Yuyang},
      journal={Transactions on Machine Learning Research},
      issn={2835-8856},
      year={2024},
      url={https://openreview.net/forum?id=gerNCVqqtR}
  }
  ```



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.


pkgId: 784d4ed41023697d81b2bd2fe57fa80324655e4fac2e4f389e974691013f902f
name: python-chronos-forecasting
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Chronos: Pretrained models for time series forecasting
url: https://github.com/amazon-science/chronos-forecasting
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronos-forecasting-1.4.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://raw.githubusercontent.com/amazon-science/chronos-forecasting/main/figures/chronos-logo.png" width="60%">
  </div>

  <div align="center">



  [![preprint](https://img.shields.io/static/v1?label=arXiv&message=2403.07815&color=B31B1B&logo=arXiv)](https://arxiv.org/abs/2403.07815)
  [![huggingface](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Datasets-FFD21E)](https://huggingface.co/datasets/autogluon/chronos_datasets)
  [![huggingface](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Models-FFD21E)](https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444)
  [![faq](https://img.shields.io/badge/FAQ-Questions%3F-blue)](https://github.com/amazon-science/chronos-forecasting/issues?q=is%3Aissue+label%3AFAQ)
  [![License: MIT](https://img.shields.io/badge/License-Apache--2.0-green.svg)](https://opensource.org/licenses/Apache-2.0)

  </div>



  - **26 Nov 2024**: ⚡️ Chronos-Bolt models released [on HuggingFace](https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444). Chronos-Bolt models are more accurate (5% lower error), up to 250x faster and 20x more memory efficient than the original Chronos models of the same size!
  - **27 Jun 2024**: 🚀 [Released datasets](https://huggingface.co/datasets/autogluon/chronos_datasets) used in the paper and an [evaluation script](./scripts/README.md#evaluating-chronos-models) to compute the WQL and MASE scores reported in the paper.
  - **17 May 2024**: 🐛 Fixed an off-by-one error in bin indices in the `output_transform`. This simple fix significantly improves the overall performance of Chronos. We will update the results in the next revision on ArXiv.
  - **10 May 2024**: 🚀 We added the code for pretraining and fine-tuning Chronos models. You can find it in [this folder](./scripts/training). We also added [a script](./scripts/kernel-synth.py) for generating synthetic time series data from Gaussian processes (KernelSynth; see Section 4.2 in the paper for details). Check out the [usage examples](./scripts/).
  - **19 Apr 2024**: 🚀 Chronos is now supported on [AutoGluon-TimeSeries](https://auto.gluon.ai/stable/tutorials/timeseries/index.html), the powerful AutoML package for time series forecasting which enables model ensembles, cloud deployments, and much more. Get started with the [tutorial](https://auto.gluon.ai/stable/tutorials/timeseries/forecasting-chronos.html).
  - **08 Apr 2024**: 🧪 Experimental [MLX inference support](https://github.com/amazon-science/chronos-forecasting/tree/mlx) added. If you have an Apple Silicon Mac, you can now obtain significantly faster forecasts from Chronos compared to CPU inference. This provides an alternative way to exploit the GPU on your Apple Silicon Macs together with the "mps" support in PyTorch.
  - **25 Mar 2024**: 🚀 [v1.1.0 released](https://github.com/amazon-science/chronos-forecasting/releases/tag/v1.1.0) with inference optimizations and `pipeline.embed` to extract encoder embeddings from Chronos.
  - **13 Mar 2024**: 🚀 Chronos [paper](https://arxiv.org/abs/2403.07815) and inference code released.



  Chronos is a family of **pretrained time series forecasting models** based on language model architectures. A time series is transformed into a sequence of tokens via scaling and quantization, and a language model is trained on these tokens using the cross-entropy loss. Once trained, probabilistic forecasts are obtained by sampling multiple future trajectories given the historical context. Chronos models have been trained on a large corpus of publicly available time series data, as well as synthetic data generated using Gaussian processes.

  For details on Chronos models, training data and procedures, and experimental results, please refer to the paper [Chronos: Learning the Language of Time Series](https://arxiv.org/abs/2403.07815).

  <p align="center">
    <img src="https://raw.githubusercontent.com/amazon-science/chronos-forecasting/main/figures/main-figure.png" width="100%">
    <br />
    <span>
      Fig. 1: High-level depiction of Chronos. (<b>Left</b>) The input time series is scaled and quantized to obtain a sequence of tokens. (<b>Center</b>) The tokens are fed into a language model which may either be an encoder-decoder or a decoder-only model. The model is trained using the cross-entropy loss. (<b>Right</b>) During inference, we autoregressively sample tokens from the model and map them back to numerical values. Multiple trajectories are sampled to obtain a predictive distribution.
    </span>
  </p>



  The models in this repository are based on the [T5 architecture](https://arxiv.org/abs/1910.10683). The only difference is in the vocabulary size: Chronos-T5 models use 4096 different tokens, compared to 32128 of the original T5 models, resulting in fewer parameters.

  <div align="center">

  | Model                                                                  | Parameters | Based on                                                               |
  | ---------------------------------------------------------------------- | ---------- | ---------------------------------------------------------------------- |
  | [**chronos-t5-tiny**](https://huggingface.co/amazon/chronos-t5-tiny)   | 8M         | [t5-efficient-tiny](https://huggingface.co/google/t5-efficient-tiny)   |
  | [**chronos-t5-mini**](https://huggingface.co/amazon/chronos-t5-mini)   | 20M        | [t5-efficient-mini](https://huggingface.co/google/t5-efficient-mini)   |
  | [**chronos-t5-small**](https://huggingface.co/amazon/chronos-t5-small) | 46M        | [t5-efficient-small](https://huggingface.co/google/t5-efficient-small) |
  | [**chronos-t5-base**](https://huggingface.co/amazon/chronos-t5-base)   | 200M       | [t5-efficient-base](https://huggingface.co/google/t5-efficient-base)   |
  | [**chronos-t5-large**](https://huggingface.co/amazon/chronos-t5-large) | 710M       | [t5-efficient-large](https://huggingface.co/google/t5-efficient-large) |
  | [**chronos-bolt-tiny**](https://huggingface.co/amazon/chronos-bolt-tiny)   | 9M         | [t5-efficient-tiny](https://huggingface.co/google/t5-efficient-tiny)   |
  | [**chronos-bolt-mini**](https://huggingface.co/amazon/chronos-bolt-mini)   | 21M        | [t5-efficient-mini](https://huggingface.co/google/t5-efficient-mini)   |
  | [**chronos-bolt-small**](https://huggingface.co/amazon/chronos-bolt-small) | 48M        | [t5-efficient-small](https://huggingface.co/google/t5-efficient-small) |
  | [**chronos-bolt-base**](https://huggingface.co/amazon/chronos-bolt-base)   | 205M       | [t5-efficient-base](https://huggingface.co/google/t5-efficient-base)   |

  </div>



  The following figure showcases the remarkable **zero-shot** performance of Chronos and Chronos-Bolt models on 27 datasets against local models, task-specific models and other pretrained models. For details on the evaluation setup and other results, please refer to [the paper](https://arxiv.org/abs/2403.07815).

  <p align="center">
    <img src="https://raw.githubusercontent.com/amazon-science/chronos-forecasting/main/figures/zero_shot-agg_scaled_score.svg" width="100%">
    <br />
    <span>
      Fig. 2: Performance of different models on Benchmark II, comprising 27 datasets <b>not seen</b> by Chronos and Chronos-Bolt models during training. This benchmark provides insights into the zero-shot performance of Chronos and Chronos-Bolt models against local statistical models, which fit parameters individually for each time series, task-specific models <i>trained on each task</i>, and pretrained models trained on a large corpus of time series. Pretrained Models (Other) indicates that some (or all) of the datasets in Benchmark II may have been in the training corpus of these models. The probabilistic (WQL) and point (MASE) forecasting metrics were normalized using the scores of the Seasonal Naive baseline and aggregated through a geometric mean to obtain the Agg. Relative WQL and MASE, respectively.
    </span>
  </p>



  To perform inference with Chronos or Chronos-Bolt models, the easiest way is to install this package through `pip`:

  ```sh
  pip install chronos-forecasting
  ```

  If you're interested in pretraining, fine-tuning, and other research & development, clone and install the package from source:

  ```sh

  git clone https://github.com/amazon-science/chronos-forecasting.git


  cd chronos-forecasting && pip install --editable ".[training]"
  ```

  > [!TIP]
  > This repository is intended for research purposes and provides a minimal interface to Chronos models. The recommended way of using Chronos for production use cases is through [AutoGluon](https://auto.gluon.ai), which features effortless fine-tuning, augmenting Chronos models with exogenous information through covariate regressors, ensembling with other statistical and machine learning models, as well as seamless deployments on AWS with SageMaker 🧠. Check out the AutoGluon Chronos [tutorial](https://auto.gluon.ai/stable/tutorials/timeseries/forecasting-chronos.html).



  A minimal example showing how to perform forecasting using Chronos and Chronos-Bolt models:

  ```python
  import pandas as pd  # requires: pip install pandas
  import torch
  from chronos import BaseChronosPipeline

  pipeline = BaseChronosPipeline.from_pretrained(
      "amazon/chronos-t5-small",  # use "amazon/chronos-bolt-small" for the corresponding Chronos-Bolt model
      device_map="cuda",  # use "cpu" for CPU inference
      torch_dtype=torch.bfloat16,
  )

  df = pd.read_csv(
      "https://raw.githubusercontent.com/AileenNielsen/TimeSeriesAnalysisWithPython/master/data/AirPassengers.csv"
  )





  quantiles, mean = pipeline.predict_quantiles(
      context=torch.tensor(df["#Passengers"]),
      prediction_length=12,
      quantile_levels=[0.1, 0.5, 0.9],
  )
  ```

  For the original Chronos models, `pipeline.predict` can be used to draw forecast samples. More options for `predict_kwargs` in `pipeline.predict_quantiles` can be found with:

  ```python
  from chronos import ChronosPipeline, ChronosBoltPipeline

  print(ChronosPipeline.predict.__doc__)  # for Chronos models
  print(ChronosBoltPipeline.predict.__doc__)  # for Chronos-Bolt models
  ```

  We can now visualize the forecast:

  ```python
  import matplotlib.pyplot as plt  # requires: pip install matplotlib

  forecast_index = range(len(df), len(df) + 12)
  low, median, high = quantiles[0, :, 0], quantiles[0, :, 1], quantiles[0, :, 2]

  plt.figure(figsize=(8, 4))
  plt.plot(df["#Passengers"], color="royalblue", label="historical data")
  plt.plot(forecast_index, median, color="tomato", label="median forecast")
  plt.fill_between(forecast_index, low, high, color="tomato", alpha=0.3, label="80% prediction interval")
  plt.legend()
  plt.grid()
  plt.show()
  ```



  A minimal example showing how to extract encoder embeddings from Chronos models:

  ```python
  import pandas as pd
  import torch
  from chronos import ChronosPipeline

  pipeline = ChronosPipeline.from_pretrained(
      "amazon/chronos-t5-small",
      device_map="cuda",
      torch_dtype=torch.bfloat16,
  )

  df = pd.read_csv("https://raw.githubusercontent.com/AileenNielsen/TimeSeriesAnalysisWithPython/master/data/AirPassengers.csv")



  context = torch.tensor(df["#Passengers"])
  embeddings, tokenizer_state = pipeline.embed(context)
  ```



  Scripts for pretraining, fine-tuning and evaluating Chronos models can be found in [this folder](./scripts/).



  Datasets used in the Chronos paper for pretraining and evaluation (both in-domain and zero-shot) are available through the HuggingFace repos: [`autogluon/chronos_datasets`](https://huggingface.co/datasets/autogluon/chronos_datasets) and [`autogluon/chronos_datasets_extra`](https://huggingface.co/datasets/autogluon/chronos_datasets_extra). Check out these repos for instructions on how to download and use the datasets.



  - [Adapting language model architectures for time series forecasting](https://www.amazon.science/blog/adapting-language-model-architectures-for-time-series-forecasting) (Amazon Science blog post)
  - [Amazon AI Researchers Introduce Chronos: A New Machine Learning Framework for Pretrained Probabilistic Time Series Models](https://www.marktechpost.com/2024/03/15/amazon-ai-researchers-introduce-chronos-a-new-machine-learning-framework-for-pretrained-probabilistic-time-series-models/) (Marktechpost blog post)
  - [Chronos: The Rise of Foundation Models for Time Series Forecasting](https://towardsdatascience.com/chronos-the-rise-of-foundation-models-for-time-series-forecasting-aaeba62d9da3) (Towards Data Science blog post by Luís Roque and Rafael Guedes)
  - [Moirai: Time Series Foundation Models for Universal Forecasting](https://towardsdatascience.com/moirai-time-series-foundation-models-for-universal-forecasting-dc93f74b330f) (Towards Data Science blog post by Luís Roque and Rafael Guedes, includes comparison of Chronos with Moirai)
  - [Chronos: The Latest Time Series Forecasting Foundation Model by Amazon](https://towardsdatascience.com/chronos-the-latest-time-series-forecasting-foundation-model-by-amazon-2687d641705a) (Towards Data Science blog post by Marco Peixeiro)
    - The original article had a critical bug affecting the metric computation for Chronos. We opened a [pull request](https://github.com/marcopeix/time-series-analysis/pull/10) to fix it.
  - [How to Effectively Forecast Time Series with Amazon's New Time Series Forecasting Model](https://towardsdatascience.com/how-to-effectively-forecast-time-series-with-amazons-new-time-series-forecasting-model-9e04d4ccf67e) (Towards Data Science blog post by Eivind Kjosbakken)
  - [Chronos: Learning the Language of Time Series](https://minimizeregret.com/linked/2024/03/27/chronos-forecasting/) (Minimize Regret blog post by Tim Radtke)
  - [Chronos: Another Zero-Shot Time Series Forecaster LLM](https://levelup.gitconnected.com/chronos-another-zero-shot-time-series-forecaster-llm-0e80753a7ad0) (Level Up Coding blog post by Level Up Coding AI TutorMaster)
  - [Paper Review: Chronos: Learning the Language of Time Series](https://andlukyane.com/blog/paper-review-chronos) (Review by Andrey Lukyanenko)
  - [Foundation Models for Forecasting: the Future or Folly?](https://insights.radix.ai/blog/foundation-models-for-forecasting-the-future-or-folly) (Blog post by Radix)
  - [Learning the Language of Time Series with Chronos](https://medium.com/@ManueleCaddeo/learning-the-language-of-time-series-with-chronos-fea7d0fedde4) (Medium post by Manuele Caddeo)
  - [The latest advancement in Time Series Forecasting from AWS: Chronos](https://medium.com/chat-gpt-now-writes-all-my-articles/the-latest-advancement-in-time-series-forecasting-from-aws-chronos-python-code-included-0205d01248f3) (Medium post by Abish Pius)
  - [Decoding the Future: How Chronos Redefines Time Series Forecasting with the Art of Language](https://medium.com/@zamalbabar/decoding-the-future-how-chronos-redefines-time-series-forecasting-with-the-art-of-language-cecc2174e400) (Medium post by Zamal)
  - [Comparison of Chronos against the SCUM ensemble of statistical models](https://github.com/Nixtla/nixtla/tree/main/experiments/amazon-chronos) (Benchmark by Nixtla)
    - We opened a [pull request](https://github.com/Nixtla/nixtla/pull/281) extending the analysis to 28 datasets (200K+ time series) and showing that **zero-shot** Chronos models perform comparably to this strong ensemble of 4 statistical models while being significantly faster on average. Our complete response can be [found here](https://www.linkedin.com/pulse/extended-comparison-chronos-against-statistical-ensemble-ansari-4aste/).
  - [Comparison of Chronos against a variety of forecasting models](https://www.linkedin.com/feed/update/urn:li:activity:7178398371815051267/) (Benchmark by ReadyTensor)



  If you find Chronos models useful for your research, please consider citing the associated [paper](https://arxiv.org/abs/2403.07815):

  ```
  @article{ansari2024chronos,
    title={Chronos: Learning the Language of Time Series},
    author={Ansari, Abdul Fatir and Stella, Lorenzo and Turkmen, Caner and Zhang, Xiyuan, and Mercado, Pedro and Shen, Huibin and Shchur, Oleksandr and Rangapuram, Syama Syndar and Pineda Arango, Sebastian and Kapoor, Shubham and Zschiegner, Jasper and Maddix, Danielle C. and Mahoney, Michael W. and Torkkola, Kari and Gordon Wilson, Andrew and Bohlke-Schneider, Michael and Wang, Yuyang},
    journal={Transactions on Machine Learning Research},
    issn={2835-8856},
    year={2024},
    url={https://openreview.net/forum?id=gerNCVqqtR}
  }
  ```



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.

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


pkgId: b212f375efd37578b7f6557fe25137d1fb37970f03f7998db25cbb93b3fd1485
name: python-chronovoyage
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Simple database migration framework.
url: https://pypi.org/project/chronovoyage/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronovoyage-0.2.2-1.src.rpm
checksum_type: sha256
description:
  - [Simple Usage](#simple-usage)
  - [Contributing](#contributing)
  - [Security Policy](#security-policy)
  - [License](#license)

  To use MariaDB version, you need the MariaDB development package (`libmariadb-dev` in apt).
  ```shell
  pip install chronovoyage[mariadb]
  ```

  First, you should name and initialize a directory.
  ```shell
  chronovoyage init my-project --vendor mariadb
  cd my-project
  ```
  Edit `config.json`.
  ```json
  {
    "$schema": "https://raw.githubusercontent.com/fairy-select/chronovoyage/main/schema/config.schema.json",
    "vendor": "mariadb",
    "connection_info": {
      "host": "127.0.0.1",
      "port": 3306,
      "user": "mariadb",
      "password": "password",
      "database": "test"
    }
  }
  ```
  Create migration template directory.
  ```shell
  chronovoyage add ddl initial_migration
  ```
  If you create DML,
  ```shell
  chronovoyage add dml second_migration
  ```
  Write up sql to `go.sql`, and rollback sql to `return.sql`.
  Then, migrate.
  ```shell
  chronovoyage migrate
  ```

  Please read the following docs before you contribute to this repo:
  - [Contributing](CONTRIBUTING.md)
  - [Code Of Conduct](CODE_OF_CONDUCT.md)

  We support the latest version based on GitHub's vulnerability alerts.
  [Security Policy](SECURITY.md)

  `chronovoyage` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
  [License](LICENSE.txt)

  - Support for
      - [x] Python 3.8 or later
      - [ ] Docker
  - Database support
      - [x] MariaDB
      - [ ] MySQL
      - [ ] PostgreSQL
  - Migration file support
      - [x] SQL (.sql)
      - [ ] Shell script (.sh)
  - Commands
      - ~~new~~ init
          - [x] Create migration directory and config file
      - ~~generate~~ add
          - [x] Create migration files from template
      - migrate
          - [x] To latest
          - [x] To specific version
          - [x] From the beginning
          - [x] From the middle
          - --dry-run
              - [ ] Show executing SQL
          - [ ] Detect ddl or dml
      - ~~status~~ current
          - [x] Show current migration status
      - rollback
          - [x] To version
      - test
          - [ ] Check if every "migrate -> rollback" operation means do nothing for schema
          - [ ] If dml, the operation means do nothing for data (including autoincrement num)
  - Other
      - [x] CLI logging
      - [x] Documentation

rpm_license:
  MIT License  Copyright (c) 2024 Noritaka IZUMI  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: 2fea99e50dbc5eed0fbcc9c8dcf843547cb055ffeb328a661228ebd2e1b94b6c
name: python-chronver
arch: src
version: 20240318.230216
epoch: 0
release: 1
summary: Setuptools plugin for chronological versions from Git
url: https://github.com/radiasoft/chronver
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chronver-20240318.230216-1.src.rpm
checksum_type: sha256
description:
  ChronVer is a
  [setuptools.meta_build](https://setuptools.pypa.io/en/latest/build_meta.html)
  plugin to add a
  [chronological version](https://www.robnagler.com/2015/04/11/Major-Release-Syndrome.html)
  (yyyymmdd.hhmmss)
  to a Python package's metadata from the current Git commit of `HEAD`.
  This ensures a unique, sortable version for packages on [PyPI](https://pypi.org).

  In development, if there are modifications, the current time will be
  returned. This ensures that `pip install` works, because there's
  always a new, increasing version.



  Add this to your `pyproject.toml`:

  ```toml
  [build-system]
  requires = ["setuptools>=61", "chronver"]
  build-backend = "setuptools.build_meta"

  [project]
  dynamic = ["version"]
  ```

  If you are using Python 3.8 or above, include this code in your
  ``<your_package>.__init__.py``:

  ```py
  import importlib.metadata

  try:
      __version__ = importlib.metadata.version("your_package")
  except importlib.metadata.PackageNotFoundError:
      
      
      
      pass
  ```

  If you are using a Python before 3.8, use the backport
  [`importlib_metadata`](https://importlib-metadata.readthedocs.io).



  [RadiaSoft](https://radiasoft.net) uses chronological versioning for
  all its releases. This means no major releases, which implies breaking
  changes.  To make this happen, we strive to maintain backward
  compatibility for as long as our users require it.

  This is why there are no major or minor release numbers in
  chronological versions; there are no breaking API changes (except
  defects, of course) with each release. We feel it is our obligation to
  not break our client's code.

  There are times when this is impossible or impractical, such as the
  move away from Python 2. In those cases, we give clients warnings and
  an upgrade path and sometimes a tool that upgrades their data or code
  automatically. This is an obligation that comes with chronological
  versioning that RadiaSoft takes seriously.



  ChronVer is a new implementation of our existing
  [setup.py versioning module](https://github.com/radiasoft/pykern/blob/eaea8492e1e8485c8b35aee67ad1204e8838da97/pykern/pksetup.py#L684)
  so it is not new at all. RadiaSoft has been using chronological
  versioning for Python, Docker images, packaging (RPMs), etc. for over
  a decade. Before that @robnagler (primary author) was using
  chronlogical versioning since at least 2000. So there's a long history
  here, and it has worked well for us.

  [SemVer](https://semver.org) makes many assumptions about how software
  works that conflicts with how we develop. In our model, software flows
  like time, and releases are arbitary points on the time axis. SemVer
  divides software releases into fixed epochs: major, minor, patch, and
  additional labels. This requires people make complicated decisions
  about these different kinds of epochs, which adds work and we think
  adds little value. This can result in
  [Major Release Syndrome](https://www.robnagler.com/2015/04/11/Major-Release-Syndrome.html),
  which is an impediment to continuous software development and
  deployment.

  [CalVer](https://calver.org) has a great tag line: "Versioning gets
  better with time." We agree! In CalVer, "time" means "date", that is,
  days are the time quantum. This granularity does not allow for same
  day releases, which we happen to do on occasion. A second is
  ChronVer's time quantum for this reason. CalVer tries to be SemVer
  compliant, which as noted above, is not how we develop software.

  There are benefits to simplifying version strings to always being
  lexicographically sortable. Any two ChronVers can be compared with a
  single operator `v1 < v2`. We have a lot internal devops tooling in
  multiple languages, and all languages support simple lexicographic
  comparison of strings. A ChronVer is compatible with Python's `float`,
  which is useful in some cases.

  A ChronVer identifies any commit in any SCM. We use Git now. We used
  to use CVS (which does not have a SHA), and ChronVer worked just as
  well. All SCM's (that we know of) answer the question: what was the
  commit at this timestamp?  SemVer and CalVer have various schemes for
  doing this, but they are awkward and break lexicographic comparison.

  For more complete reasoning, refer to
  [Major Release Syndrome](https://www.robnagler.com/2015/04/11/Major-Release-Syndrome.html).


pkgId: e6d97c81ff1273fd679a4310a4a9ce9362e02a54f595c0d5b374bb17516f07c0
name: python-chrys
arch: src
version: 4.0.30
epoch: 0
release: 1
summary: A collection of color palettes for mapping and visualisation
url: https://github.com/netbek/chrys
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrys-4.0.30-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/netbek/chrys.svg?style=svg)](https://circleci.com/gh/netbek/chrys)

  A collection of color palettes for visualisation in JavaScript, Python and Sass.



  [netbek.github.io/chrys](https://netbek.github.io/chrys#colour-schemes)





  ```shell
  npm install chrys
  ```



  ```shell
  pip install chrys
  ```



  For instructions, refer to [the docs](https://netbek.github.io/chrys#usage).



  1. Build the Docker container:

      ```shell
      ./docker/install.sh
      ```

  2. Create `.pypirc`:

      ```shell
      cp example.pypirc .pypirc
      ```

  3. Enter a [PyPI API token](https://pypi.org/manage/account/#api-tokens) as the password in `.pypirc`.



  Upgrade Node dependencies:

  ```shell
  ./docker/run.sh ./docker/scripts/upgrade_node_deps.sh
  ```

  Build the palette data, JavaScript and Python distribution packages, Sass, CSS, Illustrator scripts:

  ```shell
  ./docker/run.sh ./docker/scripts/build.sh
  ```

  Publish the JavaScript and Python distribution packages:

  ```shell
  npm publish
  npm run publish-py
  ```



  Palettes from:

  * [Bokeh](https://github.com/bokeh/bokeh) (BSD 3-Clause)
  * [Vega](https://github.com/vega/vega) (BSD 3-Clause)



  Copyright (c) 2017 Hein Bekker. Licensed under the BSD 3-Clause License.


pkgId: 16146a7627a17fb30f0282cbf0c915d1649baf94eeee2a008d01901842acc408
name: python-chrys
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: A collection of color palettes for mapping and visualisation
url: https://github.com/netbek/chrys
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chrys-4.1.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/netbek/chrys.svg?style=svg)](https://circleci.com/gh/netbek/chrys)

  A collection of color palettes for visualisation in JavaScript, Python and Sass.



  [netbek.github.io/chrys](https://netbek.github.io/chrys#colour-schemes)





  ```shell
  npm install chrys
  ```



  ```shell
  pip install chrys
  ```



  For instructions, refer to [the docs](https://netbek.github.io/chrys#usage).



  1. Install Node 18.x:

      ```shell
      curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
      source ~/.bashrc
      nvm install 18
      nvm use 18
      ```

  2. Create `.pypirc`:

      ```shell
      cp example.pypirc .pypirc
      ```

  3. Enter a [PyPI API token](https://pypi.org/manage/account/#api-tokens) as the password in `.pypirc`.



  Patch Node dependencies to fix ESM imports:

  ```shell
  npx patch-package @bokeh/bokehjs --exclude 'nothing'
  npx patch-package vega-scale --exclude 'nothing'
  ```

  Build the palette data, JavaScript and Python distribution packages, Sass, CSS, Illustrator scripts:

  ```shell
  npm run build-data
  npm run build-dist
  ```

  Publish the JavaScript and Python distribution packages:

  ```shell
  npm publish
  npm run publish-py
  ```



  Palettes from:

  * [Bokeh](https://github.com/bokeh/bokeh) (BSD 3-Clause)
  * [Vega](https://github.com/vega/vega) (BSD 3-Clause)



  Copyright (c) 2017 Hein Bekker. Licensed under the BSD 3-Clause License.


pkgId: 19cb7da237207fd7416efddf89cb1d136394100ae054548d272197adf50fbfd4
name: python-chuchichaestli
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://github.com/CAIIVS/chuchichaestli
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chuchichaestli-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  Where you find all the state-of-the-art cooking utensils (salt, pepper, gradient descent... the usual).

description:
  `chuchichaestli` is a collection of model architectures and other useful bits of code in use at the Intelligent Vision Systems group at the University of Applied Sciences Zurich (ZHAW).




  Tagged releases are available as PyPI packages. To install the latest package, run:

  ```bash
  pip install chuchichaestli
  ```

  For the bleeding-edge package directly from the git main, clone the repository and run the following command in the root directory of the repository:

  ```bash
  pip install -e .
  ```

  Alternatively, you can install the package directly from GitHub:

  ```bash
  pip install git+https://github.com/CAIIVS/chuchichaestli.git
  ```





  On the current version of the main branch, do the follwing.

  1. **Create an empty commit:**
     ```bash
     git commit --allow-empty -m "<Your commit message here>"
     ```

  2. **Add a tag to the empty commit:**
     ```bash
     git tag -a <tag_name> -m "Tagging empty commit"
     ```
     Replace `<tag_name>` with the new version The `-a` option creates an annotated tag, and the `-m` option allows you to add a message to the tag.

  3. **Push the empty commit and tag:**
     ```bash
     git push --tags
     ```

  This triggers a GitHub action that creates a PR for you to accept. Accepting the PR updates the version and triggers the release pipeline.

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


pkgId: aefbebe8ab5087cb8fe2b7b6bef7f27eff7eb719b57b41be6156dbc9151ba67a
name: python-chucks
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/chucks/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chucks-0.0.1-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install chucks
  ```

  - [ ] Pandas wrappers.
  - [ ] Analysis scripts.
  - [ ] Pandas extensions.
  - [ ] Explore the suggestion of using another Schwab python library for orders.

  This project does not include a license. All rights reserved.


pkgId: c7f09ca0362526b09519e3016a7884520609cd1d90687989633aaf81d0a1315c
name: python-chunithm-scraper
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A scraper for chunithm-net.com
url: https://github.com/taka-4602/ONGEKI.Net-CHUNITHM.Net-Scraper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chunithm-scraper-1.0.0-1.src.rpm
checksum_type: sha256
description:
  オンゲキ NET と チュウニズム NETから情報を取得するAPIラッパー、マイマイの予定はありません

  音擊
  ```
  pip install ongeki-scraper
  ```
  チュウニズム
  ```
  pip install chunithm-scraper
  ```
  必須 : requests, bs4

  他のブラウザーウィンドウなどでログインすると、今までのセッションは破棄されます

  ユーザーIDとPHPセッションIDはすぐ死んでしまいます

  あたりまえですが、無料アカウントでプレミアムアカウントの機能使ったりは無理です
  というかそもそもjson受け取れるようなAPIはなかったので100% Webスクレイピングです


  ```py
  from ongeki_screper import ONGEKI

  ongeki=ONGEKI("SEGA ID","パスワード")#SEGA IDとパスワードでログイン
  print(ongeki.token,ongeki.user_id)#セッションの維持に必要なトークンとユーザーID !!ユーザーIDという名前なだけでランダムに変わるクッキーです!!
  print(ongeki.name)#プレイヤー名
  print(ongeki.plate)#プレートの文字
  print(ongeki.rating,ongeki.raiting_max)#レート
  print(ongeki.battle_point)#バトルポイント
  print(ongeki.money,ongeki.money_total)#マニー
  print(ongeki.leveling,ongeki.leveling_reincarnation)#レベルと転生回数
  print(ongeki.icon)#アイコン画像
  print(ongeki.character)#キャラクター画像
  print(ongeki.course)#利用券
  ongeki=ONGEKI(token=ongeki.token,user_id=ongeki.user_id)#トークンとユーザーIDでログインをスキップ
  all_music=ongeki.get_all_music()#難易度別で全曲を取得
  rating_music=ongeki.check_rating_music()#レーティング対象曲をすべて取得
  print(rating_music.rating_new)#新曲枠
  print(rating_music.rating_best)#ベスト枠
  print(rating_music.rating_recent)#リーセント枠
  print(rating_music.rating_candidate)#候補枠
  check_rating_music=rating_music.rating_best[0]#ベスト枠はリストなので1番上を取得
  score_detail=ongeki.music_score_details(check_rating_music["idx"])#idxが曲の詳細を取得するためのトークンみたいなもの
  print(playlog_score_detail)
  print(score_detail.music_title)#タイトル
  print(score_detail.music_img)#ジャケットの画像
  print(score_detail.music_artist)#アーティスト
  print(score_detail.music_genre)#ジャンル
  print(score_detail.music_enemy)#敵の情報
  print(score_detail.MASTER_battle_score)#バトルスコア
  print(score_detail.MASTER_technical_score)#テクニカルスコア
  print(score_detail.MASTER_icon_technical_rank)#テクニカルランク
  print(score_detail.MASTER_over_damage)#オーバダメージ
  print(score_detail.MASTER_last_played)#最終プレイ日
  history=ongeki.get_history()#プレイ履歴を取得
  last_played=history[0]#プレイ履歴の1番上
  playlog_score_detail=ongeki.playlog_score_details(last_played["idx"])#idxを使ってプレイ履歴の詳細を取得
  print(playlog_score_detail)
  print(playlog_score_detail.music_title)#タイトル
  print(playlog_score_detail.music_img)#ジャケット画像
  print(playlog_score_detail.music_difficulty)#難易度
  print(playlog_score_detail.music_played)#プレイ日時
  print(playlog_score_detail.music_battle_score)#バトルスコア
  print(playlog_score_detail.music_technical_score)#テクニカルスコア
  print(playlog_score_detail.music_over_damage)#オーバーダメージ
  print(playlog_score_detail.max_combo)#コンボ数
  print(playlog_score_detail.critical_break)#クリティカルブレイク
  print(playlog_score_detail.ongeki_break)#ブレイク
  print(playlog_score_detail.hit)#ヒット
  print(playlog_score_detail.miss)#ミス
  print(playlog_score_detail.damage)#ダメージ
  print(playlog_score_detail.tap)#タップ
  print(playlog_score_detail.hold)#ホールド
  print(playlog_score_detail.side_tap)#サイドタップ
  print(playlog_score_detail.side_hold)#サイドホールド
  ```



  ```
  {'title': 'きゅうくらりん', 'level': '14', 'difficulty': 'Master', 'technical_score': '994,198', 'technical_score_int': 994198, 'idx': 'tD6VKJAiSJqbOH2pSJJjTON434ODt50u7C9krAwAFPPhowOm3tEW0atNrTgLAIWzQ7YaMdJxKOGOxp3urrR%2BtA%3D%3D'}
  ```
  dictの中に簡易的な説明が入ってるので単にテクニカルスコアだけ知りたい場合、スコアの詳細を取得しなくてもだいじょうぶ

  プレイ済み
  ```
  'Cutter':{'idx': 'hEr/DTD/cn70Wlvr%2BQXFdJoAZQxOqZI6ohty6tyx8O4AhuqhZKYBKf5H8/prgd3Zh72wyfQG6oVFQqNuErzKcA%3D%3D', 'battle_score': '302.01%', 'over_damage': '9,752,464', 'technical_score': '1,003,145'}
  ```
  未プレイ
  ```
  'Recollect Lines':{'idx': 'G4LE%2BayGWh88q9ziJBDOyQuZRl088qgKmAFN0hAWbd5C/UEBmGISVIASZyJJpCqSovY7EODj6EjGbMUeal/zTw%3D%3D', 'battle_score': None, 'over_damage': None, 'technical_score': None}
  ```
  dict in dictになっているため、```all_music["曲名"]``` でidxやスコアを確認できる

  ```
  SCORE_DETAILS(MASTER_level='13+', MASTER_last_played='2024/11/11 20:28', MASTER_play_count='31', MASTER_over_damage='298.52%', MASTER_battle_score='9,730,844', MASTER_technical_score='998,888', MASTER_icon_battle_rank='https://ongeki-net.com/ongeki-mobile/img/music_icon_br_great.png?ver=1.45.0', MASTER_icon_technical_rank='https://ongeki-net.com/ongeki-mobile/img/music_icon_tr_ss.png?ver=1.45.0', MASTER_icon_bell='https://ongeki-net.com/ongeki-mobile/img/music_icon_fb.png', MASTER_icon_combo='https://ongeki-net.com/ongeki-mobile/img/music_icon_back.png', EXPERT_level='12', EXPERT_last_played='2024/09/26 19:03', EXPERT_play_count='17', EXPERT_over_damage='303.69%', EXPERT_battle_score='9,396,988', EXPERT_technical_score='1,007,995', EXPERT_icon_battle_rank='https://ongeki-net.com/ongeki-mobile/img/music_icon_br_excellent.png?ver=1.45.0', EXPERT_icon_technical_rank='https://ongeki-net.com/ongeki-mobile/img/music_icon_tr_sssplus.png?ver=1.45.0', EXPERT_icon_bell='https://ongeki-net.com/ongeki-mobile/img/music_icon_fb.png', EXPERT_icon_combo='https://ongeki-net.com/ongeki-mobile/img/music_icon_fc.png?ver=1.45.0', LUNATIC_level=None, LUNATIC_last_played=None, LUNATIC_play_count=None, LUNATIC_over_damage=None, LUNATIC_battle_score=None, LUNATIC_technical_score=None, LUNATIC_icon_battle_rank=None, LUNATIC_icon_technical_rank=None, LUNATIC_icon_bell=None, LUNATIC_icon_combo=None, music_img='https://ongeki-net.com/ongeki-mobile/img/music/c159c9bee6a1fb73.png', music_title='Cyaegha', music_genre='VARIETY', music_artist='USAO「Arcaea」', music_enemy='光 Lv.35')
  ```
  レベル別になってるので長い、プレイしていないレベルは```None```

  ```
  SCORE_DETAILS(played='2024/11/11 20:34', music_img='https://ongeki-net.com/ongeki-mobile/img/music/5ab5414aa44d6a03.png', music_title='Knight Rider', music_battle_score='9,282,581', music_over_damage='323.16％', music_technical_score='986,641', max_combo='731', critical_break='1,149', ongeki_break='128', hit='39', miss='4', bell='117/117', damage='4', music_difficulty='Master', tap='95%', hold='99%', flick='99%', side_tap='96%', side_hold='100%')
  ```
  こっちはブレイク数やタップの詳細なども取得できる


  音撃とだいたい同じ...

  ```py
  from chunithm_scraper import CHUNITHM

  chunithm=CHUNITHM("SEGA ID","パスワード")#SEGA IDとパスワードでログイン
  print(chunithm.token,chunithm.php_sess_id)#セッションの維持に必要なトークンとPHPセッションID
  print(chunithm.name)#プレイヤー名
  print(chunithm.plate)#プレートの文字
  print(chunithm.rating,chunithm.raiting_max)#レート
  print(chunithm.money,chunithm.money_total)#通貨
  print(chunithm.leveling,chunithm.leveling_reincarnation)#レベルと転生回数
  print(chunithm.icon)#アイコン画像
  print(chunithm.course)#利用券
  chunithm=CHUNITHM(token=chunithm.token,php_sess_id=chunithm.php_sess_id)#トークンとPHPセッションIDでログインをスキップ
  all_music=chunithm.get_all_music()#難易度別で全曲を取得
  rating_music=chunithm.check_rating_music("Best")#レーティング対象曲を取得、Bestでベスト枠、Recentでリーセント枠、Nextで候補枠
  print(rating_music)#ベスト枠
  check_rating_music=rating_music[0]#ベスト枠の1番上を取得
  rating_music=chunithm.check_rating_music("Recent")
  print(rating_music)#リーセント枠
  rating_music=chunithm.check_rating_music("Next")
  print(rating_music)#候補枠
  score_detail=chunithm.music_score_details(check_rating_music["idx"],check_rating_music["token"])#チュウニズムの曲詳細を取得するには、idxとtokenも必要になる
  print(score_detail)
  print(score_detail.music_title)#タイトル
  print(score_detail.music_img)#ジャケットの画像
  print(score_detail.music_artist)#アーティスト
  print(score_detail.MASTER_score)#スコア
  print(score_detail.MASTER_icon_rank)#ランクの画像
  print(score_detail.MASTER_icon_clear)#クリアの画像
  print(score_detail.MASTER_icon_combo)#フルコンボとかの画像
  history=chunithm.get_history()#プレイ履歴を取得
  last_played=history[0]#プレイ履歴の1番上
  playlog_score_detail=chunithm.playlog_score_details(last_played["idx"],last_played["token"])#idxとトークンを使ってプレイ履歴の詳細を取得
  print(playlog_score_detail)
  print(playlog_score_detail.character)#キャラクター
  print(playlog_score_detail.skill)#スキル
  print(playlog_score_detail.music_img)#ジャケット画像
  print(playlog_score_detail.music_difficulty)#難易度
  print(playlog_score_detail.music_score)#スコア
  print(playlog_score_detail.music_played)#プレイ日時
  print(playlog_score_detail.max_combo)#コンボ数
  print(playlog_score_detail.justice_critical)#ジャスティスクリティカル
  print(playlog_score_detail.justice)#ジャスティス
  print(playlog_score_detail.attack)#アタック
  print(playlog_score_detail.miss)#ミス
  print(playlog_score_detail.tap)#タップ
  print(playlog_score_detail.hold)#ホールド
  print(playlog_score_detail.slide)#スライド
  print(playlog_score_detail.air)#エアー
  print(playlog_score_detail.flick)#フリック
  ```
  これも#コメントで書いてある通り...


  ```
  {'title': 'MEGALOVANIA', 'difficulty': 'Expert', 'score': '985,342', 'score_int': 985342, 'diff': '2', 'genre': '99', 'idx': '2137', 'token': 'fad775feb5e372ffa4b3d6c584422e3a'}
  ```
  dictの中に簡易的な説明が入ってるので単にテクニカルスコアだけ知りたい場合、スコアの詳細を取得しなくてもだいじょうぶ

  プレイ済み
  ```
  'レーイレーイ':{'diff': '3', 'genre': '99', 'idx': '829', 'token': '86a3e43df22bd6b63fdd97b3a5db0f47', 'score': '918,394'}
  ```
  未プレイ
  ```
  'Radiance':{'diff': '3', 'genre': '99', 'idx': '2111', 'token': 'bfa9c3e9f184e546f542df469dfbb059', 'score': None}
  ```
  dict in dictになっているため、```all_music["曲名"]``` でidxとtokenやスコアを確認できる

  ```
  SCORE_DETAILS(MASTER_play_count=None, MASTER_score=None, MASTER_icon_rank=None, MASTER_icon_combo=None, MASTER_icon_clear=None, EXPERT_play_count='1回', EXPERT_score='985,342', EXPERT_icon_rank='https://new.chunithm-net.com/chuni-mobile/html/mobile/images/icon_rank_8.png', EXPERT_icon_combo='https://new.chunithm-net.com/chuni-mobile/html/mobile/images/icon_rank_8.png', EXPERT_icon_clear='https://new.chunithm-net.com/chuni-mobile/html/mobile/images/icon_clear.png', ULTIMA_play_count=None, ULTIMA_score=None, ULTIMA_icon_rank=None, ULTIMA_icon_combo=None, ULTIMA_icon_clear=None, music_img='https://new.chunithm-net.com/chuni-mobile/html/mobile/img/f7b116709baab037.jpg', music_title='MEGALOVANIA', music_artist='Toby Fox「UNDERTALE」')
  ```
  レベル別になってるので長い、プレイしていないレベルは```None```

  ```
  SCORE_DETAILS(music_played='2024/11/11 20:46', music_img='https://new.chunithm-net.com/chuni-mobile/html/mobile/img/94e81ba6b24960b8.jpg', music_title='8OROCHI', music_score='990,754', music_difficulty='Expert', character='藤沢 柚子／デイドリーム・フェアリーズ', skill='オールガード【LMN】', max_combo='567', justice_critical='1,302', justice='122', attack='15', miss='19', tap='97.43%', hold='100.97%', slide='100.34%', air='100.84%', flick='0.00%', icon_clear='https://new.chunithm-net.com/chuni-mobile/html/mobile/images/icon_clear.png', icon_rank='https://new.chunithm-net.com/chuni-mobile/html/mobile/images/icon_rank_9.png', icon_combo='https://new.chunithm-net.com/chuni-mobile/html/mobile/images/icon_rank_9.png')
  ```
  こっちは使用キャラクター、スキル、ジャスティスやエアーの詳細なども取得できる


  えーこれオンゲキ.netだと表示できるのにチュウニズム.netじゃ見れないのかーって項目はもちろんこのスクレイパーでも取得できないし、逆も当然そう

  データベースに保存して再利用はできません

  音撃は 4:00～7:00
  チュウニズムは 2:00～7:00

  Discordで使えるオンゲキ / チュウニズムのレート確認Bot作ったけど、かなりいい感じ
  https://x.com/TakeTakaAway/status/1857697088374714646
  ![twitter](twitter.png)
  ただ100% WebスクレイピングなのでできることはWebとはまったく変わらないのが少し悲しい
  基本的にCLIで情報を確認するときなんかない (´；ω；`)
  せっかく情報が取得できるならレート計算機でもつけた方がいいかなと思ったり
  ```py
  def ongeki_rating(level:float, score:int):
      if score >= 1007500:
          return level + 2
      elif score >= 1000000:
          return round(level + 1.5 + (score - 1000000) / 15000, 2)
      elif score >= 990000:
          return round(level + 1 + (score - 990000) / 20000, 2)
      elif score >= 970000:
          return round(level + (score - 970000) / 20000, 2)
      else: #AAA以下の場合
          return round(level + (score - 970000) / 17500 ,2)
  ```
  ```py
  def chunithm_rating(level:float, score:int):
      if score >= 1009000:
          return level + 2.15
      elif score >= 1007500:
          return round(level + 2.0 + (score - 1007500) // 100 * 0.0 ,2)
      elif score >= 1005000:
          return round(level + 1.5 + (score - 1005000) // 50 * 0.01 ,2)
      elif score >= 1000000:
          return round(level + 1.0 + (score - 1000000) // 100 * 0.01 ,2)
      elif score >= 990000:
          return round(level + 0.6 + (score - 990000) // 250 * 0.01 ,2)
      elif score >= 975000:
          return round(level + (score - 975000) // 250 * 0.01 ,2)
      elif score >= 950000: #AAA以下の場合
          return round(level - 1.5 ,2)
      elif score >= 925000:
          return round(level - 3.0 ,2)
      elif score >= 900000:
          return round(level - 5.0 ,2)
      elif score >= 800000:
          return round((level - 5.0) / 2 ,2)
      else:
          return 0
  ```
  レート計算の式はこんな感じ、曲レートがわかると到達可能レートも計算できるみたいなので
  ```py
  rate_all=[]
  for best in rating_all.rating_best:
      rate_all.append(ongeki_rating(float(譜面定数),best["technical_score_int"]))

  average = sum(rate_all) / len(rate_all)
  reachable = round(average*0.75 + rate_all[0]*0.25, 2)
  ```
  これで到達可能レートが計算できるらしい、ただレベルはもちろん譜面定数が必要だけど。
  譜面定数はまた他のサイトをスクレイピングしてデータベースに保存して、そこから参照するしかない...

  Discord サーバー / https://discord.gg/aSyaAK7Ktm
  Discord ユーザー名 / .taka.


pkgId: b739205fc81db6ecebf7b8c93b2d48001fb7613dd941d2321740ea938a1be709
name: python-chunkflow
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: Composable image chunk operators to create pipeline for distributed computation.
url: https://github.com/seung-lab/chunkflow
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chunkflow-1.1.7-1.src.rpm
checksum_type: sha256
description:
  ![GitHub workflow](https://github.com/seung-lab/chunkflow/actions/workflows/.github/workflows/python-app.yml/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/pychunkflow/badge/?version=latest)](https://pychunkflow.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/chunkflow.svg)](https://badge.fury.io/py/chunkflow)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Docker Hub](https://img.shields.io/badge/docker-ready-blue.svg)](https://hub.docker.com/r/seunglab/chunkflow)
  [![Twitter URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fjingpeng_wu)](https://twitter.com/jingpeng_wu)
  <!---[![Docker Build Status](https://img.shields.io/docker/cloud/build/seunglab/chunkflow.svg)]#(https://hub.docker.com/r/seunglab/chunkflow)--->
  <!-- [![Build Status](https://travis-ci.org/seung-lab/chunkflow.svg?branch=master)](https://travis-ci.org/seung-lab/chunkflow) -->
  <!-- [![Coverage Status](https://coveralls.io/repos/github/seung-lab/chunkflow/badge.svg?branch=master)](https://coveralls.io/github/seung-lab/chunkflow?branch=master) -->

  - Petabyte scale 3D image processing is slow and computationally demanding;
  - Computation has to be distributed with linear scalability;
  - Local cluster and public cloud computing are not fully used at the same time;
  - Duplicated code across a variety of routine tasks is hard to maintain.

  - **Composable** operators. The chunk operators could be composed in a command line for flexible usage.
  - **Hybrid Cloud Distributed** computation in both local and cloud computers. The task scheduling frontend and computationally heavy backend are decoupled using AWS Simple Queue Service. The backend could be any computer with an internet connection and cloud authentication. Benefit from the robust design, the cheap unstable instances (preemptable intance in Google Cloud, spot instance in AWS) could be used to reduce cost by about threefold!
  - **Petabyte** scale. We have used chunkflow to output over eighteen-petabyte images and scaled up to 3600 nodes with NVIDIA GPUs across three regions in [Google Cloud](https://cloud.google.com/), and chunkflow is still reliable.
  - Operators work with **3D** image volumes.
  - You can **plug in** your own code as an operator.
  Check out the [Documentation](https://pychunkflow.readthedocs.io/en/latest/index.html) for [installation](https://pychunkflow.readthedocs.io/en/latest/install.html) and [usage](https://pychunkflow.readthedocs.io/en/latest/tutorial.html). Try it out by following the [tutorial](https://pychunkflow.readthedocs.io/en/latest/tutorial.html).

  Perform Convolutional net inference to segment 3D image volume with one single command!
  ```shell

  chunkflow \
      load-tif --file-name path/of/image.tif -o image \
      inference --convnet-model path/of/model.py --convnet-weight-path path/of/weight.pt \
          --input-patch-size 20 256 256 --output-patch-overlap 4 64 64 --num-output-channels 3 \
          -f pytorch --batch-size 12 --mask-output-chunk -i image -o affs \
      plugin -f agglomerate --threshold 0.7 --aff-threshold-low 0.001 --aff-threshold-high 0.9999 -i affs -o seg \
      neuroglancer -i image,affs,seg -p 33333 -v 30 6 6
  ```
  you can see your 3D image and segmentation directly in [Neuroglancer](https://github.com/google/neuroglancer)!
  ![Image_Segmentation](https://github.com/seung-lab/chunkflow/blob/master/docs/source/_static/image/image_seg.png)

  After installation, You can simply type `chunkflow` and it will list all the operators with help message. We keep adding new operators and will keep it update here. For the detailed usage, please checkout our [Documentation](https://pychunkflow.readthedocs.io/en/latest/).
  | Operator Name   | Function |
  | --------------- | -------- |
  | adjust-bbox 	  | adjust the corner offset of bounding box |
  | aggregate-skeleton-fragments| Merge skeleton fragments from chunks |
  | channel-voting  | Vote across channels of semantic map |
  | cleanup         | remove empty files to clean up storage |
  | cloud-watch     | Realtime speedometer in AWS CloudWatch |
  | connected-components | Threshold the boundary map to get a segmentation |
  | copy-var        | Copy a variable to a new name |
  | create-chunk    | Create a fake chunk for easy test |
  | create-info     | Create info file of Neuroglancer Precomputed volume |
  | crop-margin     | Crop the margin of a chunk |
  | delete-chunk    | Delete chunk in task to reduce RAM requirement |
  | delete-task-in-queue | Delete the task in AWS SQS queue |
  | downsample-upload | Downsample the chunk hierarchically and upload to volume |
  | download-mesh   | Download meshes from Neuroglancer Precomputed volume |
  | evaluate-segmentation | Compare segmentation chunks |
  | fetch-task-from-file | Fetch task from a file |
  | fetch-task-from-sqs | Fetch task from AWS SQS queue one by one |
  | generate-tasks  | Generate tasks one by one |
  | gaussian-filter | 2D Gaussian blurring operated in-place |
  | inference       | Convolutional net inference |
  | load-synapses   | Load synapses from a file |
  | save-synapses   | Save synapses as a HDF5 file. |
  | save-points     | Save point cloud as a HDF5 file. |
  | log-summary     | Summary of logs |
  | mark-complete   | mark task completion as an empty file |
  | mask            | Black out the chunk based on another mask chunk |
  | mask-out-objects| Mask out selected or small objects |
  | multiply 		  | Multiply chunks with another chunk |
  | mesh            | Build 3D meshes from segmentation chunk |
  | mesh-manifest   | Collect mesh fragments for object |
  | neuroglancer    | Visualize chunks using neuroglancer |
  | normalize-contrast-nkem | Normalize image contrast using histograms |
  | normalize-intensity | Normalize image intensity to -1:1 |
  | normalize-section-shang | Normalization algorithm created by Shang |
  | plugin          | Import local code as a customized operator. |
  | quantize        | Quantize the affinity map |
  | load-h5         | Read HDF5 files |
  | load-npy        | Read NPY files |
  | load-json       | Read JSON files |
  | load-pngs       | Read png files |
  | load-precomputed| Cutout chunk from a local/cloud storage volume |
  | load-tif        | Read TIFF files |
  | load-nrrd       | Read NRRD files |
  | load-zarr    	  | Read Zarr files |
  | remap-segmentation | Renumber a serials of segmentation chunks |
  | setup-env       | Prepare storage infor files and produce tasks |
  | skeletonize     | Create centerlines of objects in a segmentation chunk |
  | skip-task  	  | If a result file already exists, skip this task |
  | skip-all-zero   | If a chunk has all zero, skip this task |
  | skip-none       | If an item in task is None, skip this task |
  | threshold       | Use a threshold to segment the probability map |
  | view            | Another chunk viewer in browser using CloudVolume |
  | save-h5        | Save chunk as HDF5 file |
  | save-pngs      | Save chunk as a serials of png files |
  | save-precomputed| Save chunk to local/cloud storage volume |
  | save-tif       | Save chunk as TIFF file |
  | save-nrrd      | Save chunk as NRRD file |

  This package is developed at Princeton University and Flatiron Institute.

  We have a [paper](https://www.nature.com/articles/s41592-021-01088-5) for this repo:
  ```bibtex
  @article{wu_chunkflow_2021,
  	title = {Chunkflow: hybrid cloud processing of large {3D} images by convolutional nets},
  	issn = {1548-7105},
  	shorttitle = {Chunkflow},
  	url = {https://www.nature.com/articles/s41592-021-01088-5},
  	doi = {10.1038/s41592-021-01088-5},
  	journal = {Nature Methods},
  	author = {Wu, Jingpeng and Silversmith, William M. and Lee, Kisuk and Seung, H. Sebastian},
  	year = {2021},
  	pages = {1--2}
  }
  ```


pkgId: 315657e3079129ff2b0d53861818c73a291fa73f4d6be79104ab11c435c946d6
name: python-chunknorris
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A package for chunking documents from various formats
url: https://gitlab.com/wikit/research-and-development/chunk-norris
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chunknorris-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This project aims at improving the method of chunking documents from various sources (HTML, PDFs, ...).
  In the context of Retrieval Augmented Generation (RAG), an optimized chunking method might lead to smaller chunks, meaning :
  - **Better relevancy of chunks** (and thus easier identification of useful chunks through embedding cosine similarity)
  - **Less errors** because of chunks exceeding the API limit in terms of number of tokens
  - **Less hallucinations** of generation models because of superfluous information in the prompt
  - **Reduced cost** as the prompt would have reduced size



  Using Pypi, just run the following command :
  ```pip install chunknorris```



  You can directly invoke chunknorris on any **.md**, **.html** or **.pdf** file by running the following command in your terminal :

  ```chunknorris --filepath "path/to/myfile.pdf"```

  See ``chunknorris -h`` for available options. Feel free to experiment 🧪 !



  ChunkNorris relies on 3 components :
  - **Parsers** : they handle the cleaning and formating of your input document. You may use any parser suited for your need (e.g PdfParser for parsing PDF documents, MarkdownParser for parser)
  - **Chunkers** : they use the output of the parser and handle its chunking.
  - **pipelines**: they combine a parser and a chunker, allowing to output chunks directly from you input documents.



  The role of parsers is to take a file or a string as input, and output a clean formated string suited for a chunker. As of today, **3 parsers are available** :
  - ``MarkdownParser`` : for parsing markdown files/strings.
  - ``HTMLParser`` : for parsing html-formated files/strings.
  - ``PdfParser`` : for parsing PDF files.

  All parsers will output a markdown-formatted string. Indeed, markdown is a great format to be use in RAG application as it is very well understood by LLMs.



  ![](images/chunk_method.png)

  The role of chunkers is to process the output of parsers in order to obtain relevant chunks of the document. As of today, only ``MarkdownChunker`` is available. Used in conjunction with parsers, it allows to process a various inputs.

  The chunking strategy of chunkers is based on several principles:
  - **Each chunk must carry homogenous information.** To this end, they use the document's headers to chunk the documents. It helps ensuring that a specific piece of information is not splitted across multiple chunks.
  - **Each chunk must keep contextual information.** A document's section might loose its meaning if the reader as no knowledge of its context. Consequently, all the headers of the parents sections are added ad the top of the chunk.
  - **All chunks must be of similar sizes.** Indeed, when attempting to retrieve relevant chunks regarding a query, embedding models tend to be sensitive to the length of chunks. Actually, it is likely that a chunk with a text content of similar length to the query will have a high similarity score, while a chunk with a longer text content will see its similarity score descrease despite its relevancy. To prevent this, chunkers try to keep chunks of similar sizes whenever possible.




  Pipelines are the glue that sticks together a parser and a chunker. They use both to process documents and ensure constant output quality.



  You may find more detailed examples in the [examples section](link) of the repo. Nevertheless, here is a basic example to get you started, assuming you need to chunk Mardown files.

  ```py
  from chunknorris.parsers import MarkdownParser
  from chunknorris.chunkers import MarkdownChunker
  from chunknorris.pipelines import BasePipeline


  parser = MarkdownParser()
  chunker = MarkdownChunker()
  pipeline = BasePipeline(parser, chunker)


  chunks = pipeline.chunk_file(filepath="myfile.md")


  for chunk in chunks:
      print(chunk.get_text())
  pipeline.save_chunks(chunks)
  ```

  The ``BasePipeline`` is rather simple : it simply puts the parsers output into the chunker. While this is enough most in most cases, you may sometime need to use more advanced strategies.

  The ``PdfPipeline`` for example works better with ``PdfParser``, as it has a ***fallback mechanism*** toward chunking the document by page in case no headers have been found. Here is a basic example of how to use it.

  ```py
  from chunknorris.parsers import PdfParser
  from chunknorris.chunkers import MarkdownChunker
  from chunknorris.pipelines import PdfPipeline


  parser = PdfParser()
  chunker = MarkdownChunker()
  pipeline = PdfPipeline(parser, chunker)


  chunks = pipeline.chunk_file(filepath="myfile.pdf")


  for chunk in chunks:
      print(chunk.get_text())
  pipeline.save_chunks(chunks)
  ```

  Feel free to experiment with various combinations, or even to implement your the pipeline that suits your needs !.




  Additionally, the chunkers and parsers can take a number of argument allowing to modifiy their behavior:

  ```py
  from chunknorris.chunkers import MarkdownChunker

  chunker = MarkdownChunker(
      max_headers_to_use="h4",
      max_chunk_word_count=250,
      hard_max_chunk_word_count=400,
      min_chunk_word_count=15,
  )
  ```

  ***max_headers_to_use***
  (str): The maximum (included) level of headers take into account for chunking. For example, if "h3" is set, then "h4" and "h5" titles won't be used. Must be a string of type "hx" with x being the title level. Defaults to "h4".

  ***max_chunk_word_count***
  (int): The maximum size (soft limit, in words) a chunk can be. Chunk bigger that this size will be chunked using lower level headers, until no lower level headers are available. Defaults to 200.

  ***hard_max_chunk_word_count***
  (int): The hard maximum of number of words a chunk can be. Chunks bigger by this limit will be split into subchunks. ChunkNorris will try to equilibrate the size of resulting subchunks. It uses newlines to split. It should be greater than max_chunk_word_count. Defaults to 400.

  ***min_chunk_word_count***
  (int): Minimum number of words to consider keeping the chunks. Chunks with less words will be discarded. Defaults to 15.


pkgId: 17f7cc5e0cc4f7a4c8f6f9e6f8d7d334635e21c608b6889bfc17407a2f00b64f
name: python-chunli
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: chunli
url: https://github.com/luizalabs/chunli
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chunli-0.11.3-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://dutradda.github.io/chunli" target="_blank">https://dutradda.github.io/chunli</a>


pkgId: 119782e948faa809e6e42293b4e41814cd20d177885943a4afb4e3eed9174257
name: python-churchtools
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A library for the ChurchTools API
url: https://pypi.org/project/churchtools/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-churchtools-0.4.1-1.src.rpm
checksum_type: sha256
description:
  This is a python wrapper for the ChurchTools API.
  The API from ChurchTools is provided using the Swagger toolset.

  __Note:__ This library is WIP.
  Some endpoints are not implemented at all and the others are only partly
  implemented.



  To install from PyPI, you can use "`pip install churchtools`".
  Type "`pip uninstall churchtools`" to remove the library.

  Dependencies:

  - `pydantic`
  - `requests`







  Login to churchtools in your browser and copy the cookie.
  The cookie object looks something like this:

  ```python3
  cookie = {
    'ChurchTools_ct_<church_name>': 'some_random_text',
  }
  ```

  Pass this object to the init function of the `ChurchTools` class or set the
  field `cookie` in the `ChurchTools` object.



  The `ChurchTools` class provides a method `login` to log you in and set the
  cookie automatically.

  ```python3
  ct.login('your_email', 'your_password')
  ```



  You can execute the following in a python script to test the functionality.

  ```python3
  from churchtools import ChurchTools

  c = ChurchTools('https://<church_name>.church.tools')
  c.login('your_email', 'your_password')

  events = c.events.list()
  print('Upcoming event:', events[0].__repr__())
  print(events[0].dict())
  print()

  me = c.general.whoami()
  print('Logged in as:', me.__repr__())
  print()

  my_events = c.person.events(me.id)
  print('Your next events:')
  [print(f'- {e.__repr__()}') for e in my_events]
  ```



  - Set the `debugging` field from 0 - 2 for none to many debug messages.
  - Times are in UTC



  - Create a CT instance here: <https://ccp.church.tools/demo>
  - Set the environment variables `CHURCHTOOLS_URL`, `CHURCHTOOLS_USER` & `CHURCHTOOLS_PASSWORD`
  - Run `pytest`


