# packages

pkgId: 505506ac6e353809814bf36de94b0623083db8e90b3943027d5587315e6bff61
name: python-coloraide-extras
arch: src
version: 1.8
epoch: 0
release: 1
summary: Experimental plugins for ColorAide.
url: https://github.com/facelessuser/coloraide-extras
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coloraide-extras-1.8-1.src.rpm
checksum_type: sha256
description:
  [![Donate via PayPal][donate-image]][donate-link]
  [![Build][github-ci-image]][github-ci-link]
  [![Coverage Status][codecov-image]][codecov-link]
  [![PyPI Version][pypi-image]][pypi-link]
  [![PyPI Downloads][pypi-down]][pypi-link]
  [![PyPI - Python Version][python-image]][pypi-link]
  ![License][license-image-mit]





  ColorAide Extras is an add-on pack containing various plugins for [ColorAide](https://github.com/facelessuser/coloraide).
  The idea behind ColorAide Extras is to provide an environment for experimental color spaces, ∆E methods, and other
  plugins.

  Normally, it is advisable to only cherry pick color spaces you need. Rarely do people need every color space. This can
  be done simply by registering the color spaces you'd like.

  ```python
  >>> from coloraide import Color as Base
  >>> from coloraide_extras.spaces.uvw import UVW
  >>> class Color(Base): ...
  ...
  >>> Color.register(UVW())
  >>> Color('red').convert('uvw')
  color(--uvw 171.8 24.715 52.261 / 1)
  ```

  But, if you want access to all the color spaces for both ColorAide and ColorAide Extras, simply import `Color` from
  `coloraide_extras` instead of `coloraide`:

  ```python
  >>> from coloraide_extras.everything import ColorAll as Color
  >>> Color('color(--uvw 171.8 24.715 52.261 / 1)')
  color(--uvw 171.8 24.715 52.261 / 1)
  ```



  https://facelessuser.github.io/coloraide-extras



  MIT

  [github-ci-image]: https://github.com/facelessuser/coloraide-extras/workflows/build/badge.svg?branch=main&event=push
  [github-ci-link]: https://github.com/facelessuser/coloraide-extras/actions?query=workflow%3Abuild+branch%3Amain
  [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/coloraide-extras/main.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
  [codecov-link]: https://codecov.io/github/facelessuser/coloraide-extras
  [pypi-image]: https://img.shields.io/pypi/v/coloraide-extras.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-down]: https://img.shields.io/pypi/dm/coloraide-extras.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-link]: https://pypi.python.org/pypi/coloraide-extras
  [python-image]: https://img.shields.io/pypi/pyversions/coloraide_extras?logo=python&logoColor=aaaaaa&labelColor=333333
  [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
  [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
  [donate-link]: https://www.paypal.me/facelessuser


pkgId: 4ec0749b906ecb023b9f2aa7bc3cf8ce5e461f2340140f4018c952da1a267cf8
name: python-colorbar
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Colorbar in Python. Fast and lightweight!
url: https://github.com/codingfisch/colorbar
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorbar-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Add a colorbar to an image in milliseconds (faster than `plt.imshow`+`plt.colorbar`) 💨

  `colorbar` achieves its speed by avoiding [`matplotlib`](https://github.com/matplotlib/matplotlib) and instead using [`numpy`](https://github.com/numpy/numpy), [`pillow`](https://github.com/python-pillow/Pillow), [`cmap`](https://github.com/tlambert03/cmap) and [`pycairo`](https://github.com/pygobject/pycairo)!

  🛠️ Install via: `pip install colorbar` (+ if pycairo causes trouble try `conda install anaconda::pycairo`)

  ```python
  import numpy as np
  from colorbar import CBar

  shape = (400, 800)
  im = np.linspace(0, 1, shape[0] * shape[1]).reshape(*shape)  # dummy image
  cbar = CBar(cmap='gray',    # see https://cmap-docs.readthedocs.io/en/latest/catalog/
              vmin=im.min(),  # pixels <= vmin become first color of cmap
              vmax=im.max())  # pixels >= vmax become last color of cmap
  im_cbar = cbar.draw(im)  # draw colorbar!
  im_cbar.show()
  ```
  ![cbar](https://github.com/user-attachments/assets/fdfc61f8-6aeb-4895-9050-f349037675c6)

  `draw()` returns a [`PIL.Image`](https://pillow.readthedocs.io/en/stable/reference/Image.html) that is shown via [`show()`](https://pillow.readthedocs.io/en/stable/reference/ImageShow.html) and saved via [`save()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.save)
  ```python
  im_cbar.save('cbar.png')
  ```

  Use `cbar.save()` instead of `im=cbar.draw()`+`im.save()` to save the image as a vector graphic
  ```python
  ...
  cbar.save('cbar.pdf', im)  # .pdf, .svg, .ps or .eps
  ```
  To customize the colorbar, `draw()` and `save()` take the arguments:
  - `vertical`: If True, colorbar is vertical. Default: `True`
  - `pad`: Added pixel rows on the colorbar-side of the image. Default: `0`
  - `pad_color`: [Color-string](https://cmap-docs.readthedocs.io/en/latest/colors/) of added pixels. Default: `'k'`(=black)
  - `x`: Position of the colorbar center relative to image in width-direction. Default: `.9`
  - `y`: Position of the colorbar center relative to image in length-direction. Default: `.5`
  - `width`: Size of the colorbar relative to image. Default: `.05`
  - `length`: Size of the colorbar relative to image. Default: `.8`
  - `label`: Label above the colorbar. Default: `None`
  - `ticks`: List (e.g. `[0, 1]`) or dict (e.g. `{0: 'low', 1: 'high'}`) of ticks. Default: `None`
  - `fontsize`: Fontsize of labels and ticks. Default: `20`
  - `linecolor`: Color of the lines and the font used to write labels and ticks. Default: `w`(=white)
  - `linewidth`: Width of ticklines and outlines. Default: `2`
  - `tick_len`: Length of ticklines. Default: `2`

  Finally, if you want `draw()` to return a `numpy` array use `asarray=True`
  ```python
  im_cbar = cbar.draw(im, asarray=True)
  ```
  to e.g. plot it with [`matplotlib`](https://matplotlib.org/stable/tutorials/images.html#sphx-glr-tutorials-images-py) via `plt.imshow(im_cbar)`.


pkgId: e1226744bba8e9c46e8e840cbf51e5f52dbdc024b60f02277632f567f79b592d
name: python-colorcet
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Collection of perceptually uniform colormaps
url: https://colorcet.holoviz.org
rpm_license: CC-BY License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorcet-3.1.0-1.src.rpm
checksum_type: sha256
description:
  |    |    |
  | --- | --- |
  | Build Status | [![Linux/MacOS Build Status](https://github.com/holoviz/colorcet/workflows/tests/badge.svg?query=branch%3Amain)](https://github.com/holoviz/colorcet/actions/workflows/tests.yaml?query=branch%3Amain) |
  | Coverage | [![codecov](https://codecov.io/gh/holoviz/colorcet/branch/main/graph/badge.svg)](https://codecov.io/gh/holoviz/colorcet) ||
  | Latest dev release | [![Github tag](https://img.shields.io/github/tag/holoviz/colorcet.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/colorcet/tags) [![dev-site](https://img.shields.io/website-up-down-green-red/https/holoviz-dev.github.io/colorcet.svg?label=dev%20website)](https://holoviz-dev.github.io/colorcet/) |
  | Latest release | [![Github release](https://img.shields.io/github/release/holoviz/colorcet.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/colorcet/releases) [![PyPI version](https://img.shields.io/pypi/v/colorcet.svg?colorB=cc77dd)](https://pypi.python.org/pypi/colorcet) [![colorcet version](https://img.shields.io/conda/v/holoviz/colorcet.svg?colorB=4488ff&style=flat)](https://anaconda.org/holoviz/colorcet) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/colorcet.svg?label=conda%7Cconda-forge&colorB=4488ff)](https://anaconda.org/conda-forge/colorcet) [![defaults version](https://img.shields.io/conda/v/anaconda/colorcet.svg?label=conda%7Cdefaults&style=flat&colorB=4488ff)](https://anaconda.org/anaconda/colorcet) |
  | Python | [![Python support](https://img.shields.io/pypi/pyversions/colorcet.svg)](https://pypi.org/project/colorcet/) |
  | Docs | [![gh-pages](https://img.shields.io/github/last-commit/holoviz/colorcet/gh-pages.svg)](https://github.com/holoviz/colorcet/tree/gh-pages) [![site](https://img.shields.io/website-up-down-green-red/http/colorcet.holoviz.org.svg)](http://colorcet.holoviz.org) |

  Colorcet is a collection of
  perceptually uniform colormaps for use with Python plotting programs like
  [bokeh](http://bokeh.pydata.org),
  [matplotlib](http://matplotlib.org),
  [holoviews](http://holoviews.org), and
  [datashader](https://github.com/bokeh/datashader) based on the
  set of [perceptually uniform colormaps](https://arxiv.org/abs/1509.03700) created
  by Peter Kovesi at the Center for Exploration Targeting.

  Colorcet supports Python 3.7 and greater on Linux, Windows, or Mac
  and can be installed with conda:
  ```sh
  conda install colorcet
  ```
  or with pip:
  ```sh
  python -m pip install colorcet
  ```
  To work with JupyterLab you will also need the PyViz JupyterLab extension:
  ```sh
  conda install -c conda-forge jupyterlab
  jupyter labextension install @pyviz/jupyterlab_pyviz
  ```
  Once you have installed JupyterLab and the extension launch it with:
  ```sh
  jupyter-lab
  ```
  If you want to try out the latest features between releases, you can get the latest dev release by installing:
  ```sh
  conda install -c pyviz/label/dev colorcet
  ```
  For more information take a look at [Getting Started](http://colorcet.holoviz.org/getting_started).

  You can see all the details about the methods used to create these
  colormaps in [Peter Kovesi's 2015 arXiv
  paper](https://arxiv.org/pdf/1509.03700v1.pdf).  Other useful
  background is available in a [1996 paper from
  IBM](http://www.research.ibm.com/people/l/lloydt/color/color.HTM).
  The Matplotlib project also has a number of relevant resources,
  including an excellent
  [2015 SciPy talk](https://www.youtube.com/watch?v=xAoljeRJ3lU), the
  [viscm tool for creating maps like the four in mpl](https://github.com/matplotlib/viscm), the
  [cmocean site](http://matplotlib.org/cmocean/) collecting a set of maps created by viscm,
  and the [discussion of how the mpl maps were created](https://bids.github.io/colormap/).

  Some of the Colorcet colormaps that have short, memorable names (which are probably
  the most useful ones) are visible here:
  <img src="./examples/assets/images/named.png" width="800">
  But the complete set of 100+ is shown in the [User Guide](http://colorcet.holoviz.org/user_guide).


pkgId: 9cec2e46c5840440709a18b55fa02c9b781b5b6045ec8990134e4476beae9d16
name: python-colored
arch: src
version: 2.2.4
epoch: 0
release: 1
summary: Simple python library for color and formatting to terminal
url: https://pypi.org/project/colored/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colored-2.2.4-1.src.rpm
checksum_type: sha256
description:
  <a href="https://dslackw.gitlab.io/colored">
  <img src="https://gitlab.com/dslackw/colored/-/raw/site/docs/images/colored.png" title="colored"></a>



  Colored, it's a simple Python library for color and formatting in terminal.
  Collection of color codes and names for 256 color terminal setups.
  Colored now supports RGB color mode. As "true color" graphic cards with 16 to <a href="https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit" target="_blank">24 bits</a> of color became common,
  applications began to support 24-bit colors. Terminal emulators supporting setting 24-bit foreground and background
  colors with escape sequences include Xterm, KDE's <a href="https://en.wikipedia.org/wiki/Konsole" target="_blank">Konsole</a>, and iTerm, as well as all libvte based terminals,
  including <a href="https://en.wikipedia.org/wiki/GNOME_Terminal" target="_blank">GNOME Terminal</a>.

  The colors work with most terminals and terminals emulators.
  <a href="https://en.wikipedia.org/wiki/ANSI_escape_code" target="_blank">ANSI/VT100 escape sequences</a> can be used in every programming languages.

  Colored is powerful and easy to use:

  ```python title="Python 3.9.17"
  >>> from colored import Fore, Back, Style
  >>>
  >>> Fore.red
  '\x1b[38;5;1m'
  >>>
  >>> Back.red
  '\x1b[48;5;1m'
  >>>
  >>> Style.reset
  '\x1b[0m'
  >>>
  >>> Fore.rgb('100%', '50%', '30%')
  '\x1b[38;2;255;130;79m'
  >>>
  >>> print(f'{Fore.white}{Back.green}Colored is Awesome!!!{Style.reset}')
  ```
  !!! success
      <p> >>> <span style="background-color: green">
        <span style="color: white">Colored is Awesome!!!</span></span>
      </p>



  Open up a terminal and install colored with <a href="https://pip.pypa.io/en/stable/" target="_blank">pip</a> command:

  ```bash
  $ pip install colored
  ```

  Alternatively, you can grab the latest source code from <a href="https://gitlab.com/dslackw/colored" target="_blank">GitLab</a>:
  ```bash
  $ git clone https://gitlab.com/dslackw/colored.git
  $ cd colored
  $ pip install .
  ```



  The [User Guide](https://dslackw.gitlab.io/colored/user_guide/user_guide/#user-guide) is the place to go to learn how to use the library.

  The [API Reference](https://dslackw.gitlab.io/colored/api/attributes/) documentation provides API-level documentation.



  colored is made available under the MIT License. For more details, see [here](https://dslackw.gitlab.io/colored/license/#mit-license).



  !!! info
      We happily welcome [contributions](https://dslackw.gitlab.io/colored/contributors/)!



  Did you know that we developers love coffee?

  [<img src="https://gitlab.com/dslackw/colored/-/raw/site/docs/images/paypaldonate.png" alt="paypal" title="donate">](https://www.paypal.me/dslackw)


pkgId: f2a1ffcbb8675b7ca24a3be2c7204c15bc3c7321b2028ec70355ba70d68b2652
name: python-colored-custom-logger
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: A custom logger with colorful output
url: https://github.com/robin-collins/colored_custom_logger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colored-custom-logger-1.6.0-1.src.rpm
checksum_type: sha256
description:
  Made with ❤️ and 🌈 by [Robin Collins](https://github.com/robin-collins)
  Remember, life's too short for boring logs! 🎭🎨


pkgId: 589ee1cfd9f49d2e560fc9aebc2d5f4b8d0490b94884d8ffbe5433d2e7f960c2
name: python-colored-logs
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: A colored logs package based on 'colored'
url: https://github.com/kkristof200/ColoredLogs
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colored-logs-0.2.10-1.src.rpm
checksum_type: sha256
description:
  ![python_version](https://img.shields.io/static/v1?label=Python&message=3.5%20|%203.6%20|%203.7&color=blue) [![PyPI download month](https://img.shields.io/pypi/dm/colored-logs?logo=pypi&logoColor=white)](https://pypi.python.org/pypi/colored-logs/) [![PyPI version](https://img.shields.io/pypi/v/colored-logs?logo=pypi&logoColor=white)](https://pypi.python.org/pypi/colored-logs/) [![build](https://img.shields.io/travis/com/kopensource/colored_logs/develop?logo=travis)](https://travis-ci.com/github/kopensource/colored_logs) [![codecov](https://img.shields.io/codecov/c/gh/kopensource/colored_logs/develop?logo=codecov)](https://codecov.io/gh/kopensource/colored_logs) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/ead083cfe67f4ee7b65203ee8977d416)](https://www.codacy.com/gh/kopensource/colored_logs?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=kopensource/colored_logs&amp;utm_campaign=Badge_Grade) [![DeepSource](https://static.deepsource.io/deepsource-badge-dark-mini.svg)](https://deepsource.io/gh/kopensource/colored_logs/?ref=repository-badge)



  ```Bash
  pip install colored-logs
  ```
  or
  ```Bash
  pip3 install colored-logs
  ```


  * __Print different types of logs__ _(info, success, fail, warning, error, critical, subtle)_
  * __Add custom color for each type of log__ _(both foreground and background. Defaults to these [colors](https://coolors.co/b4aea8-3ea966-c8553d-f28f3b-a22b24-f3f3f3-982720-2bc4e9-918b86))_
  * __Can Provide colors in RGB, HEX, HSV, HSL, or CMYK__
  * __Mark logs with custom ids__ _(optional, defaults to no id)_
  * __Show type for every log__ _(optional, defaults to True)_
  * __Show time of logging for every log__ _(optional, defaults to True)_
  * __Change logging env to html__ _(defaults to Console. In html it appears like [this](https://jsfiddle.net/s2b4zpdq/))_
  * __Log async task__


  ```Python
  import time

  from colored_logs.logger import Logger, LogType#, LogEnvironmeent

  log = Logger(
      ID='Test-id-1'
      
      
  )

  log.info('This is an info log')
  time.sleep(0.5)

  log.ID='Test-id-2'
  log.info('This is an info log with a new id')
  log.ID='Test-id-1'
  time.sleep(0.5)

  log.success('This is a success log')
  time.sleep(0.5)
  log.warning('This is a warning log')
  time.sleep(0.5)
  log.error('This is an error log')
  time.sleep(0.5)
  log.fail('This is a fail log')
  time.sleep(0.5)
  log.critical('This is a critical log')

  time.sleep(1)

  log.start_process('This will take a while')
  time.sleep(3.5)
  log.info('This is an info log while also logging the active process')

  time.sleep(3.5)

  duration_float_seconds = log.stop_process(
      log_type=LogType.Success,
      values='Successfully finished task'
  )
  ```


  ![video](https://thumbs.gfycat.com/PleasingLikableGrouper-size_restricted.gif)


  This package was inspired by [colored](https://pypi.org/project/colored/), which is maintained by [dslackw](https://pypi.org/user/dslackw/)


pkgId: 8b6b901c2f3f2e45914f9db3ceeef4cd31b2d9475ed964806e7696115dc36627
name: python-colored-traceback
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Automatically color uncaught exception tracebacks
url: https://pypi.org/project/colored-traceback/
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colored-traceback-0.4.2-1.src.rpm
checksum_type: sha256
description:
  Automatically color Python's uncaught exception tracebacks.
  This one's for anybody who's ever struggled to read python's stacktraces on the
  terminal. Something about the two-lines-per-frame approach really just makes
  them tough to scan visually.
  Compare this:
      Traceback (most recent call last):
        File "./workflowy.py", line 525, in <module>
          main()
        File "./workflowy.py", line 37, in main
          projects = cli.load_json(args, input_is_pipe)
        File "./workflowy.py", line 153, in load_json
          return json.load(sys.stdin)
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.py", line 290, in load
          **kw)
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.py", line 338, in loads
          return _default_decoder.decode(s)
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/decoder.py", line 365, in decode
          obj, end = self.raw_decode(s, idx=_w(s, 0).end())
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/decoder.py", line 383, in raw_decode
          raise ValueError("No JSON object could be decoded")
      ValueError: No JSON object could be decoded
  To this:
      Traceback (most recent call last):
        File "./workflowy.py", line 525, in <module>
          main()
        File "./workflowy.py", line 37, in main
          projects = cli.load_json(args, input_is_pipe)
        File "./workflowy.py", line 153, in load_json
          return json.load(sys.stdin)
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.py", line 290, in load
          **kw)
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.py", line 338, in loads
          return _default_decoder.decode(s)
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/decoder.py", line 365, in decode
          obj, end = self.raw_decode(s, idx=_w(s, 0).end())
        File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/decoder.py", line 383, in raw_decode
          raise ValueError("No JSON object could be decoded")
      ValueError: No JSON object could be decoded


pkgId: a3034e2e05c2a0da8253b5093b4ce9dd4e40668c817894635a4a5acc857528b4
name: python-coloredlogs
arch: src
version: 15.0.1
epoch: 0
release: 1
summary: Colored terminal output for Python's logging module
url: https://coloredlogs.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coloredlogs-15.0.1-1.src.rpm
checksum_type: sha256
description:
  The `coloredlogs` package enables colored terminal output for Python's logging_
  module. The ColoredFormatter_ class inherits from `logging.Formatter`_ and uses
  `ANSI escape sequences`_ to render your logging messages in color. It uses only
  standard colors so it should work on any UNIX terminal. It's currently tested
  on Python 2.7, 3.5+ and PyPy (2 and 3). On Windows `coloredlogs` automatically
  tries to enable native ANSI support (on up-to-date Windows 10 installations)
  and falls back on using colorama_ (if installed). Here is a screen shot of the
  demo that is printed when the command ``coloredlogs --demo`` is executed:
  Note that the screenshot above includes custom logging levels defined by my
  verboselogs_ package: if you install both `coloredlogs` and `verboselogs` it
  will Just Work (`verboselogs` is of course not required to use
  `coloredlogs`).


pkgId: 154d85594e41e8b2c1ca3ebb9595b20b03536e9f179f82ddb706b2287bc67272
name: python-colorednoise
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Generate Gaussian (1/f)**beta noise (e.g. pink noise)
url: http://github.com/felixpatzelt/colorednoise
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorednoise-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Generate Gaussian distributed noise with a power law spectrum.
          Based on the algorithm in
              Timmer, J. and Koenig, M.:
              On generating power law noise.
              Astron. Astrophys. 300, 707-710 (1995)


pkgId: f885461389a100fab36df4c14f5a6933112145699dd567acab94f3ecd40a7422
name: python-coloredterm
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Color the text in your terminal.
url: https://github.com/hostedposted/coloredterm
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coloredterm-0.2.2-1.src.rpm
checksum_type: sha256
description:
  <h1>ColoredTerm</h1>

  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  ![PyPI](https://img.shields.io/pypi/v/coloredterm?style=for-the-badge)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/5f23efbac8a846b1b0ea32c1d007e0f0)](https://app.codacy.com/gh/hostedposted/coloredterm?utm_source=github.com&utm_medium=referral&utm_content=hostedposted/coloredterm&utm_campaign=Badge_Grade)
  [![Downloads](https://pepy.tech/badge/coloredterm)](https://pepy.tech/project/coloredterm)
  [![Documentation Status](https://readthedocs.org/projects/coloredterm/badge/?version=latest)](https://coloredterm.readthedocs.io/en/latest/?badge=latest)
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/hostedposted/coloredterm/Upload%20Python%20Package?style=for-the-badge)

  Coloredterm is a collection of functions to help you make text in your terminal a different color.

  With fg, bg, Fore, Back, Style, colored and cprint functions.





  To install the package you will need python3.6 or higher and pip installed.

  With those installed you can start.

  To install it go to your terminal and put in this command:
  ```bash
  pip install coloredterm
  ```
  Or you can download it from github.
  You can do that with:
  ```bash
  pip install git+https://github.com/hostedposted/coloredterm.git
  ```



  Here is a quick example:

  ```python
  from coloredterm import Fore, Back # Importing The Fore and Back class from coloredterm.

  print(f"{Fore.BLUE}{Back.YELLOW}Foreground of Blue Background of yellow.") # Printing text with a Foreground of Blue and Background of Yellow.
  ```

  For more please go to the [documentation](https://coloredterm.readthedocs.io/en/latest/).

  [contributors-shield]: https://img.shields.io/github/contributors/hostedposted/coloredterm.svg?style=for-the-badge
  [contributors-url]: https://github.com/hostedposted/coloredterm/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/hostedposted/coloredterm.svg?style=for-the-badge
  [forks-url]: https://github.com/hostedposted/coloredterm/network/members
  [stars-shield]: https://img.shields.io/github/stars/hostedposted/coloredterm.svg?style=for-the-badge
  [stars-url]: https://github.com/hostedposted/coloredterm/stargazers
  [issues-shield]: https://img.shields.io/github/issues/hostedposted/coloredterm.svg?style=for-the-badge
  [issues-url]: https://github.com/hostedposted/coloredterm/issues
  [license-shield]: https://img.shields.io/github/license/hostedposted/coloredterm.svg?style=for-the-badge
  [license-url]: https://github.com/hostedposted/coloredterm/blob/master/LICENSE


pkgId: c03d27846da880d6d3ce3026e4038c0e2882044d94c3ceec1d12fda9a60145a8
name: python-colorful
arch: src
version: 0.5.6
epoch: 0
release: 1
summary: Terminal string styling done right, in Python.
url: http://github.com/timofurrer/colorful
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorful-0.5.6-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/timofurrer/colorful/workflows/Continuous%20Integration/badge.svg)](https://github.com/timofurrer/colorful/actions)
  [![codecov.io](https://codecov.io/github/timofurrer/colorful/coverage.svg?branch=master)](https://codecov.io/github/timofurrer/colorful?branch=master)
  [![PyPI version](https://badge.fury.io/py/colorful.svg)](https://badge.fury.io/py/colorful)
  [![PyPI](https://img.shields.io/pypi/pyversions/colorful.svg)](https://pypi.python.org/pypi/colorful)
  [![PyPI](https://img.shields.io/pypi/wheel/colorful.svg)](https://pypi.python.org/pypi/colorful)

  Terminal string styling done right, in Python :tada:



  ![colorful example](examples/basic_example.png)

  ```python
  import colorful as cf


  print(cf.bold_white('Hello World'))

  print('{c.bold}{c.lightCoral_on_white}Hello World{c.reset}'.format(c=cf))


  print(cf.red('red {0} red'.format(cf.white('white'))))
  print(cf.red('red' + cf.white(' white ', nested=True) + 'red'))


  print(cf.bold & cf.red | 'Hello World')


  cf.use_true_colors()


  cf.update_palette({'mint': '#c5e8c8'})
  print(cf.mint_on_snow('Wow, this is actually mint'))


  cf.use_style('solarized')

  print(cf.yellow('yellow'), cf.orange('orange'),
      cf.red('red'), cf.magenta('magenta'),
      cf.violet('violet'), cf.blue('blue'),
      cf.cyan('cyan'), cf.green('green'))


  cf.print('{c.bold_blue}Hello World{c.reset}')


  with cf.with_8_ansi_colors() as c:
      print(c.bold_green('colorful is awesome!'))


  MY_COMPANY_PALETTE = {
      'companyOrange': '#f4b942',
      'companyBaige': '#e8dcc5'
  }
  with cf.with_palette(MY_COMPANY_PALETTE) as c:
      print(c.companyOrange_on_companyBaige('Thanks for choosing our product!'))


  print(f'{cf.bold}Hello World')


  print(cf.red('你好'))
  ```



  * expressive and consistent API ([docs](#style-a-string))
  * support for different color modes (8 ANSI, 256 ANSI, true colors) ([docs](#color-modes))
  * support for predefined awesome styles (solarized, ...) ([docs](#styles))
  * support for custom color palettes ([docs](#color-palette))
  * support nesting styles ([docs](#nesting-styles))
  * support for different platforms (using colorama on Windows)
  * context managers for clean color mode, color palette or style switch ([docs](#temporarily-change-colorful-settings))
  * support `len()` on colored strings ([docs](#correctly-support-the-len-protocol))
  * support color names from [X11 rgb.txt](https://en.wikipedia.org/wiki/X11_color_names) ([docs](#1-style-a-string-with-a-method-call-colorfulmodifiers_fgcolor_on_bgcolorstr-nestedfalse))
  * no dependencies



  **colorful** supports all major Python versions: *3.5*, *3.6* and *3.7*, *3.8*, *3.9*, *3.10*, *3.11*, *3.12*. <br>
  We recommend to use the latest version released on [PyPI](https://pypi.python.org/pypi/colorful):

  ```bash
  pip install colorful
  ```

  **colorful** does not require any special setup in order to be used:

  ```python
  import colorful as cf

  print(cf.italic_coral_on_beige('Hello World'))
  print(cf.italic & cf.coral_on_beige | 'Hello World')
  print('{c.italic_coral_on_beige}Hello World{c.reset}'.format(c=cf))
  ```

  Note: the entire documentation assumes `colorful` to be imported as `cf`.

  See the [Style a string](https://github.com/timofurrer/colorful#style-a-string) section for more information!



  These days terminals not only support the ancient 8 ANSI colors but often they support up to 16 Million colors with *[true color](https://en.wikipedia.org/wiki/Color_depth#True_color_.2824-bit.29)*. And if they don't support *true color* they might support the *[256 ANSI color palette](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors)* at least.

  **colorful** supports the following color modes:

  * no colors / disable (``cf.NO_COLORS``)
  * 8 colors -> 8 ANSI colors (``cf.ANSI_8_COLORS``)
  * 256 colors -> 256 ANSI color palette (8bit ``cf.ANSI_256_COLORS``)
  * 16'777'215 colors -> true color (24bit, ``cf.TRUE_COLORS``)

  By default *colorful* tries to auto detect the best supported color mode by your terminal. Consult [`cf.terminal`](https://github.com/timofurrer/colorful/blob/master/colorful/terminal.py) for more details.

  However, sometimes it makes sense to specify what color mode should be used.<br>
  **colorful** provides multiple ways to do so:



  ```python
  cf.disable()
  cf.use_8_ansi_colors()
  cf.use_256_ansi_colors()
  cf.use_true_colors()
  ```

  If you change the color mode during runtime it takes affect immediately and globally.



  ```bash
  COLORFUL_DISABLE=1 python eggs.py  # this process will not use ANY coloring
  COLORFUL_FORCE_8_COLORS=1 python eggs.py  # this process will use 8 ANSI colors by default
  COLORFUL_FORCE_256_COLORS=1 python eggs.py  # this process will use 256 ANSI colors by default
  COLORFUL_FORCE_TRUE_COLORS=1 python eggs.py  # this process will use true colors by default
  ```



  ```python
  with cf.with_8_ansi_colors() as c:
      print(c.italic_coral_on_beige('Hello world'))

  with cf.with_256_ansi_colors() as c:
      print(c.italic_coral_on_beige('Hello world'))

  with cf.with_true_colors() as c:
      print(c.italic_coral_on_beige('Hello world'))
  ```



  **colorful**'s Python API is based on *color names* like in `cf.bold_white_on_black('Hello')`. During runtime these *color names* are translated into proper [ANSI escape code](https://en.wikipedia.org/wiki/ANSI_escape_code) sequences supported by the *color mode* in use. However, all *color names* are registered in a **color palette** which is basically a mapping between the *color names* and it's corresponding RGB value. Very much like this:

  ```python
  color_palette_example = {
      'black': '#000000',
      'white': '#FFFFFF',
  }
  ```

  *Note: Depending on the color mode which is used the RGB value will be reduced to fit in the value domain of the color mode.*

  The default color palette is the [X11 rgb.txt](https://en.wikipedia.org/wiki/X11_color_names) palette - it's shipped with *colorful*, thus, you don't have to provide your own.
  *colorful* ships with a second built-in [color palette called *colornames*](https://codepen.io/meodai/full/VMpNdQ/).
  Those colors are from the curated list of the [color-names](https://github.com/meodai/color-names) repository.
  You can use those via the `cf.setup()` method, like this:


  ```python
  cf.setup(colorpalette=cf.COLORNAMES_COLORS)
  ```

  If you wish to have another color palette from a file as your default color palette you can set the `COLORFUL_DEFAULT_COLOR_PALETTE` environment variable to this file:

  ```bash
  COLORFUL_DEFAULT_COLOR_PALETTE=/usr/share/X11/rgb.txt python spam.py
  ```

  The file either has to be a txt file like the X11 rgb.txt or a JSON file:

  ```json
  [
      {"name": "18th Century Green", "hex":"#a59344"},
      {"name": "1975 Earth Red", "hex":"#7a463a"}
  ]
  ```


  **colorful** supports to update or replace the default color palette with custom colors. The colors have to be specified as RGB hex or channel values:

  ```python

  ci_colors = {
      'mint': '#c5e8c8',  # RGB hex value
      'darkRed': '#c11b55',  # RGB hex value
      'lightBlue': (15, 138, 191)  # RGB channel triplet
  }


  cf.use_palette(ci_colors)

  cf.update_palette(ci_colors)


  print(cf.italic_mint_on_darkRed('My company'))
  ```



  **colorful** supports some famous color palettes using what's called *styles* in colorful:

  ```python
  cf.use_style('solarized')


  print(cf.yellow('yellow'), cf.orange('orange'),
      cf.red('red'), cf.magenta('magenta'),
      cf.violet('violet'), cf.blue('blue'),
      cf.cyan('cyan'), cf.green('green'))
  ```

  The following styles are already supported:

  <details open>
   <summary>solarized - <a href="http://ethanschoonover.com/solarized">Website</a></summary>
   <br>
   <img src="https://github.com/timofurrer/colorful/blob/master/examples/solarized_base_colors.png" alt="solarized colors">
  </details>
  <details open>
   <summary>monokai</summary>
   <br>
   <img src="https://github.com/timofurrer/colorful/blob/master/examples/monokai_base_colors.png" alt="monokai colors">
  </details>
  <br>

  *Note: if you know some awesome color palettes which could be a new style in colorful, please contribute it!*



  **colorful** provides multiple ways to use style a string. Most useful and expressive is probably the *method syntax* where you specify the modifiers and colors in the method name itself and pass the string as argument to this method. However, you can use all the following methods to achive similars things:



  ```python
  print(cf.red('I am red'))
  print(cf.italic_yellow('I am italic and yellow'))
  print(cf.black_on_white('I am black on white'))
  ```

  The method syntax can be one of:

  * `cf.<modifier>`
  * `cf.<modifier1>_<modifier2>`
  * `cf.<fg_color>`
  * `cf.on_<bg_color>`
  * `cf.<modifiers>_<fg_color>`
  * `cf.<modifiers>_<bg_color>`
  * `cf.<fg_colors>_on_<bg_color>`
  * `cf.<modifiers>_<fg_color>_on_<bg_color>`

  *Note that multiple `<modifier>`s can be specified at once.*

  Available modifiers are:

  * reset (explicitely reset all styles before the passed argument)
  * bold
  * dimmed (not widely supported)
  * italic
  * underlined
  * blinkslow
  * blinkrapid
  * inversed (not widely supported)
  * concealed (not widely supported)
  * struckthrough

  The available colors depend on the [color palette](#color-palette) you are using. By default all [X11 rgb.txt colors](https://en.wikipedia.org/wiki/X11_color_names) are available.

  The type of the return value of such a *style method* is `colorful.ColorfulString`. It correctly supports all `str()` methods including [`len()`](#correctly-support-the-len-protocol).

  As you can see from the syntax in the section name, **colorful** supports nesting styles. See [Nesting styles](#nesting-styles).



  **colorful** implements the `__or__` and `__and__` protocol to combine styles and pipe strings into them:

  ```python
  print(cf.bold & cf.red | 'Hello World')
  print(cf.bold_red_on_black | 'Hello World')
  print(cf.bold | cf.red_on_black('Hello World')
  ```

  *Note: the piping `|` has the same effect as doing a method call to the style.<br>
  So you could do `(cf.bold & cf.red)('Hello World')`*



  ```python
  print(cf.format('{c.red}I am {what}{c.close_fg_color}', what='red'))

  print(cf.format('{c.red}I am red{c.reset}'))

  print(cf.format('{c.italic_yellow}I am italic and yellow{c.no_italic}{c.close_fg_color}'))
  print(cf.format('{c.black_on_white}I am black on white{c.close_fg_color}{c.close_bg_color}'))
  ```

  **colorful** will replace the `{c.<style>}` with the correspnding style. It's **not** necessary to pass a colorful object for `c` to `format()` - colorful will handle that. Every other format argument (`{<name>}`) has to be pass to the `cf.format()` call as *args* or *kwarg*.

  Note: The same syntax, modifiers and colors for the style in `{c.<style>}` can be used as for [(1) Style a string with a method call](#1-style-a-string-with-a-method-call).



  ```python
  cf.print('{c.italic_yellow}I am italic and yellow{c.no_italic}{c.close_fg_color}')
  cf.print('{c.red}I am red{c.reset}', end='', file=open('log.txt', 'a+'))
  ```

  The `cf.print()` method accepts the same arguments as the Python 3.X [built-in print()](https://docs.python.org/3/library/functions.html#print) function.



  ```python
  print('{c.red}I am red{c.close_fg_color}'.format(c=cf))

  print('{c.red}I am red{c.reset}'.format(c=cf))

  print('{c.italic_yellow}I am italic and yellow{c.no_italic}{c.close_fg_color}'.format(
      c=cf))
  print('{c.black_on_white}I am black on white{c.close_fg_color}{c.close_bg_color}'.format(
      c=cf))
  ```

  Note: The same syntax, modifiers and colors for the style in `{c.<style>}` can be used as for [(1) Style a string with a method call](#1-style-a-string-with-a-method-call).



  **colorful** supports to nest styles with it's [method call syntax](#1-style-a-string-with-a-method-call) when setting the parameter `nested` to `True`.
  If you are using `str.format()` like in the first example below you don't even need the `nested=True` flag!

  The following examples show the behavior:

  ```python
  print(cf.red('red {0} red'.format(cf.white('white'))))
  print(cf.red('red' + cf.white(' white ', nested=True) + 'red'))



  print(cf.red('red', nested=True) + ' default color')
  ```



  **colorful** correctly supports the `len()` protocol (`__len__`) on the styled strings. As mentioned above, when you style a string a `colorful.ColorfulString` object is returned. This object returns the length (when calling `len()`) as it would be for the *unstyled string* to integrate styled strings seemlessly into your application.

  ```python
  >>> s = 'Hello World'
  >>> len(s)
  11
  >>> len(cf.yellow(s))
  11
  >>> assert len(s) == len(cf.yellow(s))
  ```



  **colorful** provides a hand full of convenient context managers to change the colorful settings temporarily:



  Use 8 ANSI colors:

  ```python
  with cf.with_8_ansi_colors() as c:
      print(c.red('I am red'))
  ```

  Use 256 ANSI colors:

  ```python
  with cf.with_256_ansi_colors() as c:
      print(c.red('I am red'))
  ```

  Use true colors:

  ```python
  with cf.with_true_colors() as c:
      print(c.red('I am red'))
  ```



  ```python

  with cf.with_palette(my_palette) as c:
      print(c.customRed('I am custom red'))


  with cf.with_updated_palette(my_palette) as c:
      print(c.customRed('I am custom red'))
  ```



  ```python
  with cf.with_style('solarized') as c:
      print(c.red('I am solarized red'))
  ```

  ***

  *<p align="center">This project is published under [MIT](LICENSE).<br>A [Timo Furrer](https://tuxtimo.me) project.<br>- :tada: -</p>*


pkgId: e05c6f2ac8a9edc1b37f25982553c86cfd264885399cc95721cc96bee08ec281
name: python-colorful-terminal
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Print with color, style your output and take full control of your terminal.
url: https://github.com/ICreedenI/colorful_terminal
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorful-terminal-0.1.6-1.src.rpm
checksum_type: sha256
description:
  With the help of ANSI Escape Sequences, this package allows the coloring of the output as well as further sending of commands to the terminal. Highlighting text is thus very simple. It is also possible to update previous lines. This package is an altenative to colorama but provides more options.

  This has only been tested on Windows.





  - Installation

  - Description

  - Usage

  - Demonstrations

  - Limitations





  Comming soon





  The model for this package is colorama. However, the standard output is not manipulated here, but appropriate escape characters are inserted into the string. Since the color change is permanent, the colored_print function should be used so that the color settings are reset after each use. Colorama is better developed and tested, but does not offer the color selection that ANSI Escape Sequences allow.

  In addition, this package allows the cursor to be controlled by ANSI escape sequences. So you can also overwrite previous lines or hide the cursor.



  You should just try the demo. There you can see which style adjustments have an effect and which don't work. This also depends on the used terminal.





  In common usage, the corresponding string of the ANSI escape sequences is prepended to the string. Using the colored_print function will automatically reset all style adjustments. Alternatively Style.RESET_ALL can be used.

  ```python

  colored_print(Fore.RED + "This will be printet in red characters.")

  ```

  ```python

  colored_print(Back.RED + "This will be printet on a red background.")

  ```

  ```python

  print(Fore.CYAN + Style.DOUBLY_UNDERLINED + "This text is colored cyan and doubly underlined." + Style.RESET_ALL + " Dieser Text ist völlig normal.")

  ```

  *Most of the available parameters are self-explanatory, so I'll just briefly introduce most of it.*

  **See https://en.wikipedia.org/wiki/ANSI_escape_code for more information.**





  - Use **Fore** to manipulate **Foreground Colors**

  - Use **Back** to manipulate **Background Colors**

  - Normal Colors -> *Parameters* of Fore / Back:

      - `Fore.BLACK`

      - `Fore.RED`

      - `Fore.GREEN`

      - `Fore.YELLOW`

      - `Fore.BLUE`

      - `Fore.MAGENTA`

      - `Fore.CYAN`

      - `Fore.WHITE`

      - `Fore.RESET` -> resets only the foreground / background color



  - More intense Colors -> *Parameters* of Fore / Back:

      - `Fore.BRIGHT_BLACK`

      - `Fore.BRIGHT_RED`

      - `Fore.BRIGHT_GREEN`

      - `Fore.BRIGHT_YELLOW`

      - `Fore.BRIGHT_BLUE`

      - `Fore.BRIGHT_MAGENTA`

      - `Fore.BRIGHT_CYAN`

      - `Fore.BRIGHT_WHITE`



  - Most intense Colors -> *Parameters* of Fore / Back:

      - `Fore.NEON_RED`

      - `Fore.NEON_GREEN`

      - `Fore.NEON_BLUE`

      - `Fore.NEON_YELLOW`

      - `Fore.NEON_MAGENTA`

      - `Fore.NEON_CYAN`



  - *Methods* of Fore / Back:

      - `Fore.rgb(red:int=0, green:int=0, blue:int=0) -> str`

        Allows you to use any color you can create with the standard 0 to 255 color channels.



      - `Fore.color_mode_256(number) -> str`

        Choose from the 256-color lookup table

        See https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit for more information.



      - `Fore.color_mode_256_demo(colors_per_line:int=32, spacing:int=2) -> None`

        Prints every of the possible colors in the 256-color lookup table. So you don't have to open your browser to know which number you need for which color.



      - `Fore.get_rainbow_string(string:str) -> str`

        Yes, you can use it to get a string with a rainbow-like gradient. This doesn't print the string.





  - *Parameters* - probably not all of them will work

      - `Style.RESET_ALL`

      - `Style.BOLD`

      - `Style.DIM`

      - `Style.ITALIC`

      - `Style.UNDERLINED`

      - `Style.CORSSED_OUT`

      - `Style.NORMAL`

      - `Style.DOUBLY_UNDERLINED`

      - `Style.NOT_UNDERLINED`

      - `Style.NOT_CORSSED_OUT`

      - `Style.OVERLINED`

      - `Style.NOT_OVERLINED`

      - `Style.SUPERSCRIPT`

      - `Style.SUBSCRIPT`

      - `Style.NEITHER_SUPERSCRIPT_NOR_SUBSCRIPT`

  - *Method*

      - `Style.underline_rgb(red:int=0, green:int=0, blue:int=0) -> str`

        Will underline with the specified color.





  - *Parameters*

      - `TermAct.cursor_up`

        Moves the cursor 1 cell in the given direction. If the cursor is already at the edge of the screen, this has no effect.

      - `TermAct.cursor_down`

        Moves the cursor 1 cell in the given direction. If the cursor is already at the edge of the screen, this has no effect.

      - `TermAct.cursor_forward`

        Moves the cursor 1 cell in the given direction. If the cursor is already at the edge of the screen, this has no effect.

      - `TermAct.cursor_back`

        Moves the cursor 1 cell in the given direction. If the cursor is already at the edge of the screen, this has no effect.

      - `TermAct.cursor_next_line`

        Moves cursor to beginning of the line 1 line down. (not ANSI.SYS)

      - `TermAct.cursor_previous_line`

        Moves cursor to beginning of the line 1 line up. (not ANSI.SYS)

      - `TermAct.scroll_up`

        Scroll whole page up by 1 line. New lines are added at the bottom. (not ANSI.SYS)

      - `TermAct.scroll_down`

        Scroll whole page down by 1 line. New lines are added at the top. (not ANSI.SYS)

  - *Methods*

      - `TermAct.cursor_horizontal_absolute(n=1) -> str`

        Moves the cursor to column n (default 1). (not ANSI.SYS)

      - `TermAct.cursor_position(n=1, m=1) -> str`

        Moves the cursor to row n, column m. The values are 1-based, and default to 1 (top left corner) if omitted. A sequence such as CSI ;5H is a synonym for CSI 1;5H as well as CSI 17;H is the same as CSI 17H and CSI 17;1H

      - `TermAct.erase_in_display(n=0) -> str`

        Clears part of the screen. If n is 0 (or missing), clear from cursor to end of screen. If n is 1, clear from cursor to beginning of the screen. If n is 2, clear entire screen (and moves cursor to upper left on DOS ANSI.SYS). If n is 3, clear entire screen and delete all lines saved in the scrollback buffer (this feature was added for xterm and is supported by other terminal applications).

      - `TermAct.erase_in_line(n=0) -> str`

        Erases part of the line. If n is 0 (or missing), clear from cursor to the end of the line. If n is 1, clear from cursor to beginning of the line. If n is 2, clear entire line. Cursor position does not change.

      - `TermAct.horizontal_vertical_position(n, m) -> str`

        Same as CUP, but counts as a format effector function (like CR or LF) rather than an editor function (like CUD or CNL). This can lead to different handling in certain terminal modes.

      - `TermAct.sgr_reset() -> str`

        Resets colors and style of the characters following this code.

      - `TermAct.save_current_cursor_position() -> str`

        Saves the cursor position/state in SCO console mode. In vertical split screen mode, instead used to set (as CSI n ; n s) or reset left and right margins.

      - `TermAct.restore_saved_cursor_position() -> str`

        Restores the cursor position/state in SCO console mode.

      - `TermAct.show_cursor() -> str`

        Shows the cursor, from the VT220.

      - `TermAct.hide_cursor() -> str`

        Hides the cursor.

      - `TermAct.undo_line()`

        Goes one line up and clears the line.

      - `TermAct.clear_current_line()`

        Clears everything in current line.

      - `clear_terminal()`

        Clears your terminal with either cls or clear

      - `TermAct.clear_console()`

        Alias for clear_terminal





  - colored_print(*args, end="  n", sep=" ")

    Use just like print. Pay attention: Writing `colored_print(Fore.RED, "This is red.")` will print `" This is red."` since the seperator is `" "`. Choose a `+` instaed of the comma to avoid this

    -> `colored_print(Fore.RED + "This is red.")`



  Using the print function will not reset your manipulations automatically. You will need to add `Style.RESET_ALL` to reset all changes.





  There are 6 demo prints (`foreground_demo`, `background_demo`, `style_demo`, `rgb_demo`, `rainbow_demo`, `termact_demo`), the function `demo_print` will call all of them.

  Each demo will show the special effects you can create with this package.

  Here is an image that shows what to expect.

  ![Demo-Screenshot](images/demo_screenshot.png "Demo-Screenshot")





  Some packages like *colorama* and *moviepy* break this package because they manipulate the terminal output, while colorful_terminal does not interfere with other terminal output because the colored_print function always resets the terminal output settings.


pkgId: d5eaf4ed4b60380b9145c4db47f0d43c149566b33beaba2ad822346569c068a6
name: python-colorgram.py
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A Python module for extracting colors from images. Get a palette of any picture!
url: https://github.com/obskyr/colorgram.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorgram.py-1.2.0-1.src.rpm
checksum_type: sha256
description:
  **colorgram.py** is a Python library that lets you extract colors from images. Compared to other libraries, the colorgram algorithm's results are more intense.
  colorgram.py is a port of `colorgram.js <https://github.com/darosh/colorgram-js>`__, a JavaScript library written by GitHub user `@darosh <https://github.com/darosh>`__. The goal is to have 100% accuracy to the results of the original library (a goal that is met). I decided to port it since I much prefer the results the colorgram algorithm gets over those of alternative libraries - have a look in the next section.


pkgId: 669914ba5e61c6547f778d08debd56478f48066da70a65f9c205d855c62502d6
name: python-colorhash
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Generate color based on any object
url: https://github.com/dimostenis/color-hash-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorhash-2.0.0-1.src.rpm
checksum_type: sha256
description:
  **Generate a color based on a value**

  This module generates a color based on an object, by calculating a color value
  based on a hash value for the object. This means the result is deterministic:
  the same value will always result in the same color (so long as the hash
  function remains deterministic).

  This module is a port of the [color-hash Javascript library](https://github.com/zenozeng/color-hash).

  It supports Python 3.7+ and it has no dependencies.



  ```python
  >>> from colorhash import ColorHash
  >>> c = ColorHash('Hello World')
  >>> c.hsl
  (131, 0.65, 0.5)
  >>> c.rgb
  (45, 210, 75)
  >>> c.hex
  '#2dd24b'
  ```



  Its hosted on PyPI.

  ```bash
  pip install colorhash
  ```



  You can influence every aspect of final color. **Default values** are following:

  ```python
  ColorHash(
      obj: Any,
      lightness: Sequence[float, ...] = (0.35, 0.5, 0.65),  # picks 'randomly' one
      saturation: Sequence[float, ...] = (0.35, 0.5, 0.65),  # picks 'randomly' one
      min_h: Optional[int] = None,  # hue, min 0
      max_h: Optional[int] = None,  # hue, max 360
  )
  ```

  But be careful, **setting tight conditions may result in very similar colors**. See example tables.

  You can fix lightness or saturation to single value(s) by using sequence with 1 element (eg. `[0.5]`).

  | code                                  | hex       | color                           |
  |:--------------------------------------|:---------:|:-------------------------------:|
  | `ColorHash('hey')  # default` | `#782d86` | ![#782d86](./docs/782d86.png) |
  | `ColorHash('hey', lightness=[0.55])` | `#b453c6` | ![#b453c6](./docs/b453c6.png) |
  | `ColorHash('hey', lightness=[0.75])` | `#d69fdf` | ![#d69fdf](./docs/d69fdf.png) |
  | `ColorHash('hey', lightness=[0.95])` | `#f7ecf9` | ![#f7ecf9](./docs/f7ecf9.png) |
  | `ColorHash('hey', saturation=[0.15])` | `#8d6c93` | ![#8d6c93](./docs/8d6c93.png) |
  | `ColorHash('hey', saturation=[0.55])` | `#b139c6` | ![#b139c6](./docs/b139c6.png) |
  | `ColorHash('hey', saturation=[0.95])` | `#d406f9` | ![#d406f9](./docs/d406f9.png) |
  | `ColorHash('hey', lightness=[0.95], saturation=[0.95])` | `#fbe6fe` | ![#fbe6fe](./docs/fbe6fe.png) |
  | `ColorHash('oh', lightness=[0.95], saturation=[0.95])` | `#fef0e6` | ![#fef0e6](./docs/fef0e6.png) |
  | `ColorHash('boi', lightness=[0.95], saturation=[0.95])` | `#e6fee7` | ![#e6fee7](./docs/e6fee7.png) |

  You can set hue range or even fix it by setting `min_h` = `max_h`.

  | code                                  | hex       | color                           |
  |:--------------------------------------|:---------:|:-------------------------------:|
  | `ColorHash('hey', min_h=150)` | `#2d5886` | ![#2d5886](./docs/2d5886.png) |
  | `ColorHash('hey', min_h=300)` | `#862d6c` | ![#862d6c](./docs/862d6c.png) |
  | `ColorHash('hey', max_h=150)` | `#866e2d` | ![#866e2d](./docs/866e2d.png) |
  | `ColorHash('hey', min_h=150, max_h=360)` | `#2d5886` | ![#2d5886](./docs/2d5886.png) |
  | `ColorHash('hey', min_h=150, max_h=150)  # fixed hue` | `#2d8659` | ![#2d8659](./docs/2d8659.png) |

  Or you can let `ColorHash` decide between combination of many `lightness` and `saturation` options (mind `min_h` and `max_h` are equal in this example).

  | code                                  | hex       | color                           |
  |:--------------------------------------|:---------:|:-------------------------------:|
  | `ColorHash('stick', min_h=65, max_h=65, saturation=[x/10 for x in range(1, 10)], lightness=[x/10 for x in range(1, 10)])` | `#869108` | ![#869108](./docs/869108.png) |
  | `ColorHash('with', min_h=65, max_h=65, saturation=[x/10 for x in range(1, 10)], lightness=[x/10 for x in range(1, 10)])` | `#eef5a3` | ![#eef5a3](./docs/eef5a3.png) |
  | `ColorHash('one', min_h=65, max_h=65, saturation=[x/10 for x in range(1, 10)], lightness=[x/10 for x in range(1, 10)])` | `#ddeb47` | ![#ddeb47](./docs/ddeb47.png) |

  Finally some bad examples. When you set too strict rules, colors may be almost identical.

  | code                                  | hex       | color                           |
  |:--------------------------------------|:---------:|:-------------------------------:|
  | `ColorHash('lets', lightness=[0.95], saturation=[0.95], min_h=300)` | `#fee6f8` | ![#fee6f8](./docs/fee6f8.png) |
  | `ColorHash('break', lightness=[0.95], saturation=[0.95], min_h=300)` | `#fee6fb` | ![#fee6fb](./docs/fee6fb.png) |
  | `ColorHash('it', lightness=[0.95], saturation=[0.95], min_h=300)` | `#fee6fa` | ![#fee6fa](./docs/fee6fa.png) |
  | `ColorHash('here', min_h=150, max_h=150)` | `#6ce0a6` | ![#6ce0a6](./docs/6ce0a6.png) |
  | `ColorHash('goes', min_h=150, max_h=150)` | `#79d2a6` | ![#79d2a6](./docs/79d2a6.png) |
  | `ColorHash('almost', min_h=150, max_h=150)` | `#6ce0a6` | ![#6ce0a6](./docs/6ce0a6.png) |
  | `ColorHash('same', min_h=150, max_h=150)` | `#79d2a6` | ![#79d2a6](./docs/79d2a6.png) |
  | `ColorHash('color', min_h=150, max_h=150)` | `#6ce0a6` | ![#6ce0a6](./docs/6ce0a6.png) |




  - color-hash **2.0.0** *(2023-09-22)*
    - ✨ Expose params to influence colors
    - ✨ Runtime validation of input params
    - 📝 Update docs for advanced usage
  - color-hash **1.3.2** *(2023-09-21)*
    - ⚡️ 30%+ speedup on `hsl2rgb()`
    - ✅ Add tests for all named colors (1500+ tests)
  - color-hash **1.3.1** *(2023-09-21)*
    - 🐛 Handle missing `importlib-metadata` import
  - color-hash **1.3.0** *(2023-09-20)*
    - 🧑‍💻 Add `py.typed` to support type annotations (#4)
    - 📦 Changed packaging ecosystem
      - ➖ Remove `poetry`
      - ➖ Remove `tox`
      - ➕ Add `pip-tools` (manage dependencies)
      - ➕ Add `hatch` (build & test)
      - ➕ Add `twine` (publish)
    - ✨ Support `python3.11`
    - ⚰️ Drop support for `python3.6` (downloads from PyPI are under 1%)
  - color-hash **1.2.2** *(2022-10-17)*
    - ✨ Add publish helper script
  - color-hash **1.2.1** *(2022-10-17)*
    - 📝 Update docs
  - color-hash **1.2.0** *(2022-10-17)*
    - 🧑‍💻 Use typing supporting `python3.6`
  - color-hash **1.1.0** *(2022-09-01)*
    - ✅ Add tests
    - 🚸 Add installation instructions
  - color-hash **1.0.4** *(2021-11-30)*
    - Support only for `python3.6+`
    - ✅ Add tests
  - color-hash **1.0.3** *(2020-12-04)*
    - ⚰️ Drop support for `python2.x`
    - 🎉 Handover of project maintenance
  - color-hash **1.0.2** *(2016-07-08)*
    - ✨ Add ``crc32_hash`` function and set default hashfunc to that. It's not
      fully backwards-compatible, but I don't want to bump the version a lot for
      not doing my research.
  - color-hash **1.0.0** *(2016-07-07)*
    - 🎉 Initial port.



  Running `pytest` (1600+ tests) on different python versions.

  | python | secs    |
  | :----: | :-----: |
  | 3.7    | `1.252` |
  | 3.8    | `1.239` |
  | 3.9    | `0.720` |
  | 3.10   | `0.690` |
  | 3.11   | `0.892` |



  Copyright (c) 2016 Felix Krull <f_krull@gmx.de>

  This is a port of the 'color-hash' Javascript library which is:

  Copyright (c) 2015 Zeno Zeng

  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: 5cdd92a27901ee8fafa4546d901532aad703d16c6cc48b734526c7ce2a963395
name: python-colorich
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/colorich/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorich-0.6.3-1.src.rpm
checksum_type: sha256
description:
  Python module - Use ANSI formatting to color output text by hexadecimal values, RGB values or by color specific name or decorate it

  Use ANSI formatting to color output text by hexadecimal values, RGB values or by color specific name or decorate
  it.\
  The color names and values is inspired by https://www.w3schools.com/colors/colors_names.asp and
  https://github.com/jonathantneal

  Functions:\
  expand - Expands the colors list, extra colors will be available if this function will be executed.

  enrich - Return colored and decorated font for rgb values or for hex.\
  e.g. print(enrich("SeaGreen", (45, 140, 85)), "\n")\
  This example will color and print the text "SeaGreen" in the rgb color of (45, 140, 85) (Green) and start a new line

  dye - Only determine the foreground color of the font but can accept a dictionary of strings with their different colors values.\
  e.g. print(dye({"Periwinkle ": "periwinkle ", "Iceberg ": "Ice berg", "and ": "", "Forest green\n": "Forest green"}))\
  This example will color and print the text "Periwinkle Iceberg and Forest green" with several colors - every word will be colored with the color that is writen next to it, notice that the word "and" won't be colored because no color has been writen next to it.

  printr - Prints the decorated colorized text that have sent as argument.\
  e.g. printr("Bold Turquoise on MediumSlateBlue", (64, 224, 208), "#7B68EE", "B", "\n")\
  This example will color, decorate and print the text "Bold Turquoise on MediumSlateBlue" as it says.\
  (64, 224, 208) is the text color, #7B68EE is the background color, "B" makes it bold, and \n will start a new line.

  printd - Prints text that have sent as an argument in multiple colors.\
  e.g. printd("Red ; red", "Slate Blue ; slateBlue", "default color ", "and; Orange Red\n; OrangeRed")\
  This example will color and print the text "Red Slate Blue default color and Orange Red" with several colors and eventualy will start a new line.

  show - prints all the colors and decorations name available and how it looks like.

  Examples are in the bottom of the main file.


pkgId: c916a603a091819e538a6b7938527245fddc75bf741a50b9d76ff62e3df468b3
name: python-colorific
arch: src
version: 0.3
epoch: 0
release: 1
summary: Automatic color palette detection
url: http://github.com/99designs/colorific
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorific-0.3-1.src.rpm
checksum_type: sha256
description:
  Image palette detection in Python modelled after Paul Annesley's color detector
  in PHP. colorific determines what the most important colors used in your image
  are, and if one of them is a background color.
  *by Dennis Hotson & Lars Yencken*


pkgId: 8c80f68ec889b1f792eaa76d257245436687ee6e0d263daed21371c95ce420f7
name: python-colorist
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: Colorist for Python
url: https://jakob-bagterp.github.io/colorist-for-python/
rpm_license: 3-Clause BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorist-1.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Latest version](https://img.shields.io/static/v1?label=version&message=1.8.1&color=yellowgreen)](https://github.com/jakob-bagterp/colorist-for-python/releases/latest)
  [![Python 3.10 | 3.11 | 3.12 | 3.13+](https://img.shields.io/static/v1?label=python&message=3.10%20|%203.11%20|%203.12%20|%203.13%2B&color=blueviolet)](https://www.python.org)
  [![BSD-3-Clause license](https://img.shields.io/static/v1?label=license&message=BSD-3-Clause&color=blue)](https://github.com/jakob-bagterp/colorist-for-python/blob/master/LICENSE.md)
  [![Codecov](https://codecov.io/gh/jakob-bagterp/colorist-for-python/branch/master/graph/badge.svg?token=1E69VOP4ED)](https://codecov.io/gh/jakob-bagterp/colorist-for-python)
  [![CodeQL](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/codeql.yml/badge.svg)](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/codeql.yml)
  [![Test](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/test.yml/badge.svg)](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/test.yml)
  [![Downloads](https://static.pepy.tech/badge/colorist)](https://pepy.tech/project/colorist)


  Lightweight Python package that makes it easy and fast to print colored text in the terminal.

  Ready to try? See [how to install](https://jakob-bagterp.github.io/colorist-for-python/getting-started/installation/).



  How to print a full line of colored text in the terminal:

  ```python
  from colorist import green, yellow, red

  green("This is GREEN!")
  yellow("This is YELLOW!")
  red("This is RED!")
  ```

  How it appears in the terminal:

  ![Example of full line of green, yellow, red colored text printed in a terminal window](/docs/assets/images/examples/color_full_text_green_yellow_red.png)


  How to customize colors inside a paragraph and print it in the terminal:

  ```python
  from colorist import Color

  print(f"I want {Color.RED}red{Color.OFF} color inside this paragraph")

  print(f"Both {Color.GREEN}green{Color.OFF} and {Color.YELLOW}yellow{Color.OFF} are nice colors")
  ```

  How it appears in the terminal:

  ![Example of white text mixed with green, yellow, red colors printed in a terminal window](/docs/assets/images/examples/color_custom_text_green_yellow_red.png)



  Most terminals support bright colors that stand more out:

  ```python
  from colorist import BrightColor

  print(f"I want {BrightColor.CYAN}cyan{BrightColor.OFF} color inside this paragraph")
  ```

  How it appears in the terminal:

  ![Example of white text mixed with cyan printed in a terminal window](/docs/assets/images/examples/bright_color_custom_text_cyan.png)

  Remember to use `Color.OFF` or `BrightColor.OFF` every time you want to revert back to the default terminal text style. Otherwise, the color may spill over and into other terminal messages.


  ```python
  from colorist import bg_green, bg_yellow, bg_red

  bg_green("This is GREEN background!")
  bg_yellow("This is YELLOW background!")
  bg_red("This is RED background!")
  ```

  How it appears in the terminal:

  ![Example of white text and colored backgrounds if green, yellow, red printed in a terminal window](/docs/assets/images/examples/bg_color_full_text_green_yellow_red.png)

  Background colors can also be mixed inside a paragraph:

  ```python
  from colorist import BgColor

  print(f"I want {BgColor.RED}red{BgColor.OFF} background color inside this paragraph")

  print(f"Both {BgColor.GREEN}green{BgColor.OFF} and {BgColor.YELLOW}yellow{BgColor.OFF} are nice background colors")
  ```

  How it appears in the terminal:

  ![Example of black, green, yellow, red background colors mixed inside paragraph printed in a terminal window](/docs/assets/images/examples/bg_color_custom_text_green_yellow_red.png)

  ```python
  from colorist import BgBrightColor

  print(f"I want {BgBrightColor.CYAN}cyan{BgBrightColor.OFF} background color inside this paragraph")
  ```

  How it appears in the terminal:

  ![Example of white text on a cyan background color printed in a terminal window](/docs/assets/images/examples/bg_bright_color_custom_text_cyan.png)

  As with text colors, remember to use `BgColor.OFF` or `BgBrightColor.OFF` every time you want to revert back to the default terminal text style. Otherwise, the color may spill over and into other terminal messages.


  | Color | Full Text Function | Custom | Example |
  | ----- | ------------------ | ------ | ------- |
  | ![Green](/docs/assets/images/colors/green_16x16.png) | `green("text")` | `Color.GREEN` | ![Green text color in terminal](/docs/assets/images/examples/color_map/green_full_text_167x16.png) |
  | ![Yellow](/docs/assets/images/colors/yellow_16x16.png) | `yellow("text")` | `Color.YELLOW` | ![Yellow text color in terminal](/docs/assets/images/examples/color_map/yellow_full_text_167x16.png) |
  | ![Red](/docs/assets/images/colors/red_16x16.png) | `red("text")` | `Color.RED` | ![Red text color in terminal](/docs/assets/images/examples/color_map/red_full_text_167x16.png) |
  | ![Magenta](/docs/assets/images/colors/magenta_16x16.png) | `magenta("text")` | `Color.MAGENTA` | ![Magenta text color in terminal](/docs/assets/images/examples/color_map/magenta_full_text_167x16.png) |
  | ![Blue](/docs/assets/images/colors/blue_16x16.png) | `blue("text")` | `Color.BLUE` | ![Blue text color in terminal](/docs/assets/images/examples/color_map/blue_full_text_167x16.png) |
  | ![Cyan](/docs/assets/images/colors/cyan_16x16.png) | `cyan("text")` | `Color.CYAN` | ![Cyan text color in terminal](/docs/assets/images/examples/color_map/cyan_full_text_167x16.png) |
  | ![White](/docs/assets/images/colors/white_16x16.png) | `white("text")` | `Color.WHITE` | ![White text color in terminal](/docs/assets/images/examples/color_map/white_full_text_167x16.png) |
  | ![Black](/docs/assets/images/colors/black_16x16.png) | `black("text")` | `Color.BLACK` | ![Black text color in terminal](/docs/assets/images/examples/color_map/black_full_text_167x16.png) |
  | - | - | `Color.DEFAULT` | - |
  | - | - | `Color.OFF` | - |
  | ![Bright green](/docs/assets/images/colors/bright_green_16x16.png) | `bright_green("text")` | `BrightColor.GREEN` | ![Bright green text color in terminal](/docs/assets/images/examples/color_map/bright_green_full_text_167x16.png) |
  | ![Bright yellow](/docs/assets/images/colors/bright_yellow_16x16.png) | `bright_yellow("text")` | `BrightColor.YELLOW` | ![Bright yellow text color in terminal](/docs/assets/images/examples/color_map/bright_yellow_full_text_167x16.png) |
  | ![Bright red](/docs/assets/images/colors/bright_red_16x16.png) | `bright_red("text")` | `BrightColor.RED` | ![Bright red text color in terminal](/docs/assets/images/examples/color_map/bright_red_full_text_167x16.png) |
  | ![Bright magenta](/docs/assets/images/colors/bright_magenta_16x16.png) | `bright_magenta("text")` | `BrightColor.MAGENTA` | ![Bright magenta text color in terminal](/docs/assets/images/examples/color_map/bright_magenta_full_text_167x16.png) |
  | ![Bright blue](/docs/assets/images/colors/bright_blue_16x16.png) | `bright_blue("text")` | `BrightColor.BLUE` | ![Bright blue text color in terminal](/docs/assets/images/examples/color_map/bright_blue_full_text_167x16.png) |
  | ![Bright cyan](/docs/assets/images/colors/bright_cyan_16x16.png) | `bright_cyan("text")` | `BrightColor.CYAN` | ![Bright cyan text color in terminal](/docs/assets/images/examples/color_map/bright_cyan_full_text_167x16.png) |
  | ![Bright white](/docs/assets/images/colors/bright_white_16x16.png) | `bright_white("text")` | `BrightColor.WHITE` | ![Bright white text color in terminal](/docs/assets/images/examples/color_map/bright_white_full_text_167x16.png) |
  | ![Bright black](/docs/assets/images/colors/bright_black_16x16.png) | `bright_black("text")` | `BrightColor.BLACK` | ![Bright black text color in terminal](/docs/assets/images/examples/color_map/bright_black_full_text_167x16.png) |
  | - | - | `BrightColor.DEFAULT` | - |
  | - | - | `BrightColor.OFF` | - |


  | Color | Full Text Function | Custom | Example |
  | ----- | ------------------ | ------ | ------- |
  | ![Green](/docs/assets/images/colors/green_16x16.png) | `bg_green("text")` | `BgColor.GREEN` | ![Green background color in terminal](/docs/assets/images/examples/bg_color_map/green_full_text_194x16.png) |
  | ![Yellow](/docs/assets/images/colors/yellow_16x16.png) | `bg_yellow("text")` | `BgColor.YELLOW` | ![Yellow background color in terminal](/docs/assets/images/examples/bg_color_map/yellow_full_text_194x16.png) |
  | ![Red](/docs/assets/images/colors/red_16x16.png) | `bg_red("text")` | `BgColor.RED` | ![Red background color in terminal](/docs/assets/images/examples/bg_color_map/red_full_text_194x16.png) |
  | ![Magenta](/docs/assets/images/colors/magenta_16x16.png) | `bg_magenta("text")` | `BgColor.MAGENTA` | ![Magenta background color in terminal](/docs/assets/images/examples/bg_color_map/magenta_full_text_194x16.png) |
  | ![Blue](/docs/assets/images/colors/blue_16x16.png) | `bg_blue("text")` | `BgColor.BLUE` | ![Blue background color in terminal](/docs/assets/images/examples/bg_color_map/blue_full_text_194x16.png) |
  | ![Cyan](/docs/assets/images/colors/cyan_16x16.png) | `bg_cyan("text")` | `BgColor.CYAN` | ![Cyan background color in terminal](/docs/assets/images/examples/bg_color_map/cyan_full_text_194x16.png) |
  | ![White](/docs/assets/images/colors/white_16x16.png) | `bg_white("text")` | `BgColor.WHITE` | ![White background color in terminal](/docs/assets/images/examples/bg_color_map/white_full_text_194x16.png) |
  | ![Black](/docs/assets/images/colors/black_16x16.png) | `bg_black("text")` | `BgColor.BLACK` | ![Black background color in terminal](/docs/assets/images/examples/bg_color_map/black_full_text_194x16.png) |
  | - | - | `BgColor.DEFAULT` | - |
  | - | - | `BgColor.OFF` | - |
  | ![Bright green](/docs/assets/images/colors/bright_green_16x16.png) | `bg_bright_green("text")` | `BgBrightColor.GREEN` | ![Bright green background color in terminal](/docs/assets/images/examples/bg_color_map/bright_green_full_text_194x16.png) |
  | ![Bright yellow](/docs/assets/images/colors/bright_yellow_16x16.png) | `bg_bright_yellow("text")` | `BgBrightColor.YELLOW` | ![Bright yellow background color in terminal](/docs/assets/images/examples/bg_color_map/bright_yellow_full_text_194x16.png) |
  | ![Bright red](/docs/assets/images/colors/bright_red_16x16.png) | `bg_bright_red("text")` | `BgBrightColor.RED` | ![Bright red background color in terminal](/docs/assets/images/examples/bg_color_map/bright_red_full_text_194x16.png) |
  | ![Bright magenta](/docs/assets/images/colors/bright_magenta_16x16.png) | `bg_bright_magenta("text")` | `BgBrightColor.MAGENTA` | ![Bright magenta background color in terminal](/docs/assets/images/examples/bg_color_map/bright_magenta_full_text_194x16.png) |
  | ![Bright blue](/docs/assets/images/colors/bright_blue_16x16.png) | `bg_bright_blue("text")` | `BgBrightColor.BLUE` | ![Bright blue background color in terminal](/docs/assets/images/examples/bg_color_map/bright_blue_full_text_194x16.png) |
  | ![Bright cyan](/docs/assets/images/colors/bright_cyan_16x16.png) | `bg_bright_cyan("text")` | `BgBrightColor.CYAN` | ![Bright cyan background color in terminal](/docs/assets/images/examples/bg_color_map/bright_cyan_full_text_194x16.png) |
  | ![Bright white](/docs/assets/images/colors/bright_white_16x16.png) | `bg_bright_white("text")` | `BgBrightColor.WHITE` | ![Bright white background color in terminal](/docs/assets/images/examples/bg_color_map/bright_white_full_text_194x16.png) |
  | ![Bright black](/docs/assets/images/colors/bright_black_16x16.png) | `bg_bright_black("text")` | `BgBrightColor.BLACK` | ![Bright black background color in terminal](/docs/assets/images/examples/bg_color_map/bright_black_full_text_194x16.png) |
  | - | - | `BgBrightColor.DEFAULT` | - |
  | - | - | `BgBrightColor.OFF` | - |



  This module is free to use. And if you like it, feel free to [buy me a coffee](https://github.com/sponsors/jakob-bagterp).


  If you have suggestions or changes to the module, feel free to add to the code and create a [pull request](https://github.com/jakob-bagterp/colorist-for-python/pulls).


  Report bugs and issues [here](https://github.com/jakob-bagterp/colorist-for-python/issues).



  Copyright (c) 2022 – present, Jakob Bagterp

  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: d6cb482f56c234972ffc92ae40c16003df66c6a317e3e2958b039eea0c61e572
name: python-colorist
arch: src
version: 1.8.3
epoch: 0
release: 1
summary: Colorist for Python
url: https://jakob-bagterp.github.io/colorist-for-python/
rpm_license: 3-Clause BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorist-1.8.3-1.src.rpm
checksum_type: sha256
description:
  [![Latest version](https://img.shields.io/static/v1?label=version&message=1.8.3&color=yellowgreen)](https://github.com/jakob-bagterp/colorist-for-python/releases/latest)
  [![Python 3.10 | 3.11 | 3.12 | 3.13+](https://img.shields.io/static/v1?label=python&message=3.10%20|%203.11%20|%203.12%20|%203.13%2B&color=blueviolet)](https://www.python.org)
  [![BSD-3-Clause license](https://img.shields.io/static/v1?label=license&message=BSD-3-Clause&color=blue)](https://github.com/jakob-bagterp/colorist-for-python/blob/master/LICENSE.md)
  [![Codecov](https://codecov.io/gh/jakob-bagterp/colorist-for-python/branch/master/graph/badge.svg?token=1E69VOP4ED)](https://codecov.io/gh/jakob-bagterp/colorist-for-python)
  [![CodeQL](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/codeql.yml/badge.svg)](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/codeql.yml)
  [![Test](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/test.yml/badge.svg)](https://github.com/jakob-bagterp/colorist-for-python/actions/workflows/test.yml)
  [![Downloads](https://static.pepy.tech/badge/colorist)](https://pepy.tech/project/colorist)


  Lightweight Python package that makes it easy and fast to print colored text in the terminal.

  Ready to try? See [how to install](https://jakob-bagterp.github.io/colorist-for-python/getting-started/installation/).



  How to print a full line of colored text in the terminal:

  ```python
  from colorist import green, yellow, red

  green("This is GREEN!")
  yellow("This is YELLOW!")
  red("This is RED!")
  ```

  How it appears in the terminal:

  ![Example of full line of green, yellow, red colored text printed in a terminal window](/docs/assets/images/examples/color_full_text_green_yellow_red.png)


  How to customize colors inside a paragraph and print it in the terminal:

  ```python
  from colorist import Color

  print(f"I want {Color.RED}red{Color.OFF} color inside this paragraph")

  print(f"Both {Color.GREEN}green{Color.OFF} and {Color.YELLOW}yellow{Color.OFF} are nice colors")
  ```

  How it appears in the terminal:

  ![Example of white text mixed with green, yellow, red colors printed in a terminal window](/docs/assets/images/examples/color_custom_text_green_yellow_red.png)



  Most terminals support bright colors that stand more out:

  ```python
  from colorist import BrightColor

  print(f"I want {BrightColor.CYAN}cyan{BrightColor.OFF} color inside this paragraph")
  ```

  How it appears in the terminal:

  ![Example of white text mixed with cyan printed in a terminal window](/docs/assets/images/examples/bright_color_custom_text_cyan.png)

  Remember to use `Color.OFF` or `BrightColor.OFF` every time you want to revert back to the default terminal text style. Otherwise, the color may spill over and into other terminal messages.


  ```python
  from colorist import bg_green, bg_yellow, bg_red

  bg_green("This is GREEN background!")
  bg_yellow("This is YELLOW background!")
  bg_red("This is RED background!")
  ```

  How it appears in the terminal:

  ![Example of white text and colored backgrounds if green, yellow, red printed in a terminal window](/docs/assets/images/examples/bg_color_full_text_green_yellow_red.png)

  Background colors can also be mixed inside a paragraph:

  ```python
  from colorist import BgColor

  print(f"I want {BgColor.RED}red{BgColor.OFF} background color inside this paragraph")

  print(f"Both {BgColor.GREEN}green{BgColor.OFF} and {BgColor.YELLOW}yellow{BgColor.OFF} are nice background colors")
  ```

  How it appears in the terminal:

  ![Example of black, green, yellow, red background colors mixed inside paragraph printed in a terminal window](/docs/assets/images/examples/bg_color_custom_text_green_yellow_red.png)

  ```python
  from colorist import BgBrightColor

  print(f"I want {BgBrightColor.CYAN}cyan{BgBrightColor.OFF} background color inside this paragraph")
  ```

  How it appears in the terminal:

  ![Example of white text on a cyan background color printed in a terminal window](/docs/assets/images/examples/bg_bright_color_custom_text_cyan.png)

  As with text colors, remember to use `BgColor.OFF` or `BgBrightColor.OFF` every time you want to revert back to the default terminal text style. Otherwise, the color may spill over and into other terminal messages.


  | Color | Full Text Function | Custom | Example |
  | ----- | ------------------ | ------ | ------- |
  | ![Green](/docs/assets/images/colors/green_16x16.png) | `green("text")` | `Color.GREEN` | ![Green text color in terminal](/docs/assets/images/examples/color_map/green_full_text_167x16.png) |
  | ![Yellow](/docs/assets/images/colors/yellow_16x16.png) | `yellow("text")` | `Color.YELLOW` | ![Yellow text color in terminal](/docs/assets/images/examples/color_map/yellow_full_text_167x16.png) |
  | ![Red](/docs/assets/images/colors/red_16x16.png) | `red("text")` | `Color.RED` | ![Red text color in terminal](/docs/assets/images/examples/color_map/red_full_text_167x16.png) |
  | ![Magenta](/docs/assets/images/colors/magenta_16x16.png) | `magenta("text")` | `Color.MAGENTA` | ![Magenta text color in terminal](/docs/assets/images/examples/color_map/magenta_full_text_167x16.png) |
  | ![Blue](/docs/assets/images/colors/blue_16x16.png) | `blue("text")` | `Color.BLUE` | ![Blue text color in terminal](/docs/assets/images/examples/color_map/blue_full_text_167x16.png) |
  | ![Cyan](/docs/assets/images/colors/cyan_16x16.png) | `cyan("text")` | `Color.CYAN` | ![Cyan text color in terminal](/docs/assets/images/examples/color_map/cyan_full_text_167x16.png) |
  | ![White](/docs/assets/images/colors/white_16x16.png) | `white("text")` | `Color.WHITE` | ![White text color in terminal](/docs/assets/images/examples/color_map/white_full_text_167x16.png) |
  | ![Black](/docs/assets/images/colors/black_16x16.png) | `black("text")` | `Color.BLACK` | ![Black text color in terminal](/docs/assets/images/examples/color_map/black_full_text_167x16.png) |
  | - | - | `Color.DEFAULT` | - |
  | - | - | `Color.OFF` | - |
  | ![Bright green](/docs/assets/images/colors/bright_green_16x16.png) | `bright_green("text")` | `BrightColor.GREEN` | ![Bright green text color in terminal](/docs/assets/images/examples/color_map/bright_green_full_text_167x16.png) |
  | ![Bright yellow](/docs/assets/images/colors/bright_yellow_16x16.png) | `bright_yellow("text")` | `BrightColor.YELLOW` | ![Bright yellow text color in terminal](/docs/assets/images/examples/color_map/bright_yellow_full_text_167x16.png) |
  | ![Bright red](/docs/assets/images/colors/bright_red_16x16.png) | `bright_red("text")` | `BrightColor.RED` | ![Bright red text color in terminal](/docs/assets/images/examples/color_map/bright_red_full_text_167x16.png) |
  | ![Bright magenta](/docs/assets/images/colors/bright_magenta_16x16.png) | `bright_magenta("text")` | `BrightColor.MAGENTA` | ![Bright magenta text color in terminal](/docs/assets/images/examples/color_map/bright_magenta_full_text_167x16.png) |
  | ![Bright blue](/docs/assets/images/colors/bright_blue_16x16.png) | `bright_blue("text")` | `BrightColor.BLUE` | ![Bright blue text color in terminal](/docs/assets/images/examples/color_map/bright_blue_full_text_167x16.png) |
  | ![Bright cyan](/docs/assets/images/colors/bright_cyan_16x16.png) | `bright_cyan("text")` | `BrightColor.CYAN` | ![Bright cyan text color in terminal](/docs/assets/images/examples/color_map/bright_cyan_full_text_167x16.png) |
  | ![Bright white](/docs/assets/images/colors/bright_white_16x16.png) | `bright_white("text")` | `BrightColor.WHITE` | ![Bright white text color in terminal](/docs/assets/images/examples/color_map/bright_white_full_text_167x16.png) |
  | ![Bright black](/docs/assets/images/colors/bright_black_16x16.png) | `bright_black("text")` | `BrightColor.BLACK` | ![Bright black text color in terminal](/docs/assets/images/examples/color_map/bright_black_full_text_167x16.png) |
  | - | - | `BrightColor.DEFAULT` | - |
  | - | - | `BrightColor.OFF` | - |


  | Color | Full Text Function | Custom | Example |
  | ----- | ------------------ | ------ | ------- |
  | ![Green](/docs/assets/images/colors/green_16x16.png) | `bg_green("text")` | `BgColor.GREEN` | ![Green background color in terminal](/docs/assets/images/examples/bg_color_map/green_full_text_194x16.png) |
  | ![Yellow](/docs/assets/images/colors/yellow_16x16.png) | `bg_yellow("text")` | `BgColor.YELLOW` | ![Yellow background color in terminal](/docs/assets/images/examples/bg_color_map/yellow_full_text_194x16.png) |
  | ![Red](/docs/assets/images/colors/red_16x16.png) | `bg_red("text")` | `BgColor.RED` | ![Red background color in terminal](/docs/assets/images/examples/bg_color_map/red_full_text_194x16.png) |
  | ![Magenta](/docs/assets/images/colors/magenta_16x16.png) | `bg_magenta("text")` | `BgColor.MAGENTA` | ![Magenta background color in terminal](/docs/assets/images/examples/bg_color_map/magenta_full_text_194x16.png) |
  | ![Blue](/docs/assets/images/colors/blue_16x16.png) | `bg_blue("text")` | `BgColor.BLUE` | ![Blue background color in terminal](/docs/assets/images/examples/bg_color_map/blue_full_text_194x16.png) |
  | ![Cyan](/docs/assets/images/colors/cyan_16x16.png) | `bg_cyan("text")` | `BgColor.CYAN` | ![Cyan background color in terminal](/docs/assets/images/examples/bg_color_map/cyan_full_text_194x16.png) |
  | ![White](/docs/assets/images/colors/white_16x16.png) | `bg_white("text")` | `BgColor.WHITE` | ![White background color in terminal](/docs/assets/images/examples/bg_color_map/white_full_text_194x16.png) |
  | ![Black](/docs/assets/images/colors/black_16x16.png) | `bg_black("text")` | `BgColor.BLACK` | ![Black background color in terminal](/docs/assets/images/examples/bg_color_map/black_full_text_194x16.png) |
  | - | - | `BgColor.DEFAULT` | - |
  | - | - | `BgColor.OFF` | - |
  | ![Bright green](/docs/assets/images/colors/bright_green_16x16.png) | `bg_bright_green("text")` | `BgBrightColor.GREEN` | ![Bright green background color in terminal](/docs/assets/images/examples/bg_color_map/bright_green_full_text_194x16.png) |
  | ![Bright yellow](/docs/assets/images/colors/bright_yellow_16x16.png) | `bg_bright_yellow("text")` | `BgBrightColor.YELLOW` | ![Bright yellow background color in terminal](/docs/assets/images/examples/bg_color_map/bright_yellow_full_text_194x16.png) |
  | ![Bright red](/docs/assets/images/colors/bright_red_16x16.png) | `bg_bright_red("text")` | `BgBrightColor.RED` | ![Bright red background color in terminal](/docs/assets/images/examples/bg_color_map/bright_red_full_text_194x16.png) |
  | ![Bright magenta](/docs/assets/images/colors/bright_magenta_16x16.png) | `bg_bright_magenta("text")` | `BgBrightColor.MAGENTA` | ![Bright magenta background color in terminal](/docs/assets/images/examples/bg_color_map/bright_magenta_full_text_194x16.png) |
  | ![Bright blue](/docs/assets/images/colors/bright_blue_16x16.png) | `bg_bright_blue("text")` | `BgBrightColor.BLUE` | ![Bright blue background color in terminal](/docs/assets/images/examples/bg_color_map/bright_blue_full_text_194x16.png) |
  | ![Bright cyan](/docs/assets/images/colors/bright_cyan_16x16.png) | `bg_bright_cyan("text")` | `BgBrightColor.CYAN` | ![Bright cyan background color in terminal](/docs/assets/images/examples/bg_color_map/bright_cyan_full_text_194x16.png) |
  | ![Bright white](/docs/assets/images/colors/bright_white_16x16.png) | `bg_bright_white("text")` | `BgBrightColor.WHITE` | ![Bright white background color in terminal](/docs/assets/images/examples/bg_color_map/bright_white_full_text_194x16.png) |
  | ![Bright black](/docs/assets/images/colors/bright_black_16x16.png) | `bg_bright_black("text")` | `BgBrightColor.BLACK` | ![Bright black background color in terminal](/docs/assets/images/examples/bg_color_map/bright_black_full_text_194x16.png) |
  | - | - | `BgBrightColor.DEFAULT` | - |
  | - | - | `BgBrightColor.OFF` | - |



  This module is free to use. And if you like it, feel free to [buy me a coffee](https://github.com/sponsors/jakob-bagterp).


  If you have suggestions or changes to the module, feel free to add to the code and create a [pull request](https://github.com/jakob-bagterp/colorist-for-python/pulls).


  Report bugs and issues [here](https://github.com/jakob-bagterp/colorist-for-python/issues).



  Copyright (c) 2022 – present, Jakob Bagterp

  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 98aeb431f612a1baf329a78279e7d2fa8c58b45ff75485aaaa816e7fd24b3247
name: python-colormath
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Color math and conversion library.
url: https://github.com/gtaylor/python-colormath
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colormath-3.0.0-1.src.rpm
checksum_type: sha256
description:
  This module implements a large number of different color operations such as
  color space conversions, Delta E, and density to spectral.


pkgId: 4dd0753185264480dfff73abbecf07377fb56b9373cb1072fd998dd41db9608a
name: python-colorsphere
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Select colors on a 3D sphere
url: https://github.com/Anders-Holst/colorsphere
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorsphere-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This module implements an interactive 3-dimensional color picker -
  to the author's knowledge the first ever 3-dimensional color picker.

  The color sphere represents the whole color body, where one pole
  is black, the other pole is white, and the color circle is around the
  equator. If you follow a meridian from the black pole, the color will
  gradually increase in strength to its maximum brilliance and then
  seamlessly continue to become brighter all the way to white. Less
  saturated colors are inside the sphere. The axis through the middle of
  the sphere between the poles contains all grays from black to
  white. Thus, the hue is represented by the longitude, the lightness by
  the latitude, and the saturation by the proportion from the surface to
  the center black-white axis of the sphere. You can rotate the sphere
  either by dragging the surface, or using the arrow keys. The scroll
  wheel takes you inside the sphere.

  In the default usage, clicking a color in the sphere will print out
  its RGB and HSL (hue, saturation, lightness) color coordinates.
  However, the main purpose is to use it as a color picker from within
  other python programs.


pkgId: f80d096ba947f7280fcee53b1b6e92e7555808b87fda5d5d50960f97a932d5c6
name: python-colorsynth
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A Python library for creating false-color images from arrays of spectral radiance
url: https://github.com/sun-data/colorsynth
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorsynth-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/sun-data/colorsynth/actions/workflows/tests.yml/badge.svg)](https://github.com/sun-data/colorsynth/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/gh/sun-data/colorsynth/graph/badge.svg?token=8QettIppCi)](https://codecov.io/gh/sun-data/colorsynth)
  [![Black](https://github.com/sun-data/colorsynth/actions/workflows/black.yml/badge.svg)](https://github.com/sun-data/colorsynth/actions/workflows/black.yml)
  [![Documentation Status](https://readthedocs.org/projects/colorsynth/badge/?version=latest)](https://colorsynth.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/colorsynth.svg)](https://badge.fury.io/py/colorsynth)

  A Python library for creating false-color images from 3D Numpy arrays of spectral intensity.



  `colorsynth` is available on the Python Package Index and can be installed using `pip`:
  ```
  pip install colorsynth
  ```



  An Si IV 1403 A spectroheliogram captured by the [Interface Region Imaging Spectrograph](iris.lmsal.com) and colorized using
  [`colorsynth.rgb()`](https://colorsynth.readthedocs.io/en/latest/_autosummary/colorsynth.rgb.html#colorsynth.rgb).
  The code to create this image can be found in the [documentation](https://colorsynth.readthedocs.io/).

  ![IRIS spectroheliogram](https://colorsynth.readthedocs.io/en/latest/_images/index_0_1.png)


pkgId: ea169b500211e5e2f18d90361279a33ddefa2c75958441b18bf0bf5e06f538a0
name: python-colorthief
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A module for grabbing the color palette from an image.
url: https://github.com/fengsp/color-thief-py
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colorthief-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A module for grabbing the color palette from an image.
  Links
  `````
  * `github <https://github.com/fengsp/color-thief-py>`_
  * `development version
    <http://github.com/fengsp/color-thief-py/zipball/master#egg=color-thief-py-dev>`_


pkgId: 42d4f48ff8e3ea7463cdec7d051c6392641239c5700f3395ec65c519b5701e4f
name: python-colortimelog
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A util for logging the time elapsed for a task.
url: https://github.com/wq2012/colortimelog
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colortimelog-0.0.9-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/wq2012/colortimelog/actions/workflows/python-package.yml/badge.svg)](https://github.com/wq2012/colortimelog/actions/workflows/python-package.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/colortimelog.svg)](https://pypi.python.org/pypi/colortimelog)
  [![Python Versions](https://img.shields.io/pypi/pyversions/colortimelog.svg)](https://pypi.org/project/colortimelog)
  [![Downloads](https://static.pepy.tech/badge/colortimelog)](https://www.pepy.tech/projects/colortimelog)



  ```
  pip install colortimelog
  ```



  Add timing for a function:

  ```python
  import colortimelog

  @colortimelog.timefunc
  def my_function():
    ...
  ```

  Add timeing for a block of code:

  ```python
  import colortimelog

  with colortimelog.timeblock("Doing XYC"):
    do_x()
    do_y()
    do_z()
  ```

  Logging with verbosity control:

  ```python
  import colortimelog

  logger = colortimelog.Logger(verbosity=3)
  logger.error("This is an error")
  logger.info("This is info")
  logger.fatal("This will fail")
  ```


pkgId: 1a1e430638dc323f3b5dd3be54ce1e01526bc077e7ce5b9b94c3ac52ecdbf2a6
name: python-colortool
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: set of tools to work with different color formats
url: https://pypi.org/project/colortool/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colortool-0.6.0-1.src.rpm
checksum_type: sha256
description:
  set of tools to work with different color formats


  ```shell
  pip install colortool
  ```


  ```python
  >>> from colortool import Color

  ```


  ```python
  >>> green = Color.from_hex(0x00FF00)
  >>> green.css_hex
  '#00FF00'
  >>> green.rgb_int
  (0, 255, 0)
  >>> green.rgb_float
  (0.0, 1.0, 0.0)
  >>> green.hsl
  (0.33333333333333, 1.0, 0.5)

  ```


  ```python
  >>> Color.from_css_hex('#00FF00')
  Color(0x00FF00)
  >>> Color.from_rgb_int((0, 255, 0))
  Color(0x00FF00)
  >>> Color.from_rgb_float((0.0, 1.0, 0.0))
  Color(0x00FF00)
  >>> Color.from_hsl((0.3333333333333333, 1.0, 0.5))
  Color(0x00FF00)

  ```


  ```python
  >>> Color.from_rgba_int_float((0, 255, 0, 0.5))
  Color(0x00FF00, alpha=0.5)

  >>> Color.from_rgba_int_float((0, 255, 0, 0.5)).css_rgb
  'rgba(0, 255, 0, 0.5)'

  ```

  ```python

  >>> Color.from_background_and_color_alpha(
  ...     background=Color(0x00FF00),
  ...     color=Color(0x000000,alpha=0.5),
  ... )
  Color(0x007F00)

  ```


  ```python
  >>> green.darker(ratio=0.5) # lightness = lightness * ratio
  Color(0x007F00)
  >>> green.lighter(ratio=0.5) # lightness = lightness + (1 - lightness) * ratio
  Color(0x7FFF7F)

  ```

  ```python
  >>> white = Color(0xFFFFFF)
  >>> black = Color(0x000000)
  >>> white.font_color()
  Color(0x000000)
  >>> black.font_color()
  Color(0xFFFFFF)
  >>> green.font_color()
  Color(0x000000)

  ```


  ```python
  >>> green.font_border_colors()
  (Color(0x000000), Color(0x00FF00))

  ```


pkgId: 472ff005df99b9c274caf1dff84d152dfea5556bec569dce069668200f6114ac
name: python-colortype
arch: src
version: 4
epoch: 0
release: 1
summary: A module that use ANSI code to change your text color, text type
url: https://pypi.org/project/colortype/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colortype-4-1.src.rpm
checksum_type: sha256
description:
  * Use ANSI to color, style of the text

  * Have no change

  * Have no change


  * fore, back and style


  * ANSIControl and goto


pkgId: 4e7d7f6e007295562ec1a805f47a697251da2e0de1ce1c7329e353016929f0ba
name: python-colossalai
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: An integrated large-scale model training system with efficient parallelization techniques
url: https://www.colossalai.org
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colossalai-0.4.4-1.src.rpm
checksum_type: sha256
description:
  <div id="top" align="center">

     [![logo](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/colossal-ai_logo_vertical.png)](https://www.colossalai.org/)

     Colossal-AI: Making large AI models cheaper, faster, and more accessible

     <h3> <a href="https://arxiv.org/abs/2110.14883"> Paper </a> |
     <a href="https://www.colossalai.org/"> Documentation </a> |
     <a href="https://github.com/hpcaitech/ColossalAI/tree/main/examples"> Examples </a> |
     <a href="https://github.com/hpcaitech/ColossalAI/discussions"> Forum </a> |
     <a href="https://cloud.luchentech.com/">GPU Cloud Playground </a> |
     <a href="https://hpc-ai.com/blog"> Blog </a></h3>

     [![GitHub Repo stars](https://img.shields.io/github/stars/hpcaitech/ColossalAI?style=social)](https://github.com/hpcaitech/ColossalAI/stargazers)
     [![Build](https://github.com/hpcaitech/ColossalAI/actions/workflows/build_on_schedule.yml/badge.svg)](https://github.com/hpcaitech/ColossalAI/actions/workflows/build_on_schedule.yml)
     [![Documentation](https://readthedocs.org/projects/colossalai/badge/?version=latest)](https://colossalai.readthedocs.io/en/latest/?badge=latest)
     [![CodeFactor](https://www.codefactor.io/repository/github/hpcaitech/colossalai/badge)](https://www.codefactor.io/repository/github/hpcaitech/colossalai)
     [![HuggingFace badge](https://img.shields.io/badge/%F0%9F%A4%97HuggingFace-Join-yellow)](https://huggingface.co/hpcai-tech)
     [![slack badge](https://img.shields.io/badge/Slack-join-blueviolet?logo=slack&amp)](https://github.com/hpcaitech/public_assets/tree/main/colossalai/contact/slack)
     [![WeChat badge](https://img.shields.io/badge/微信-加入-green?logo=wechat&amp)](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/WeChat.png)


     | [English](README.md) | [中文](docs/README-zh-Hans.md) |

  </div>


  * [2024/06] [Open-Sora Continues Open Source: Generate Any 16-Second 720p HD Video with One Click, Model Weights Ready to Use](https://hpc-ai.com/blog/open-sora-from-hpc-ai-tech-team-continues-open-source-generate-any-16-second-720p-hd-video-with-one-click-model-weights-ready-to-use)
  * [2024/05] [Large AI Models Inference Speed Doubled, Colossal-Inference Open Source Release](https://hpc-ai.com/blog/colossal-inference)
  * [2024/04] [Open-Sora Unveils Major Upgrade: Embracing Open Source with Single-Shot 16-Second Video Generation and 720p Resolution](https://hpc-ai.com/blog/open-soras-comprehensive-upgrade-unveiled-embracing-16-second-video-generation-and-720p-resolution-in-open-source)
  * [2024/04] [Most cost-effective solutions for inference, fine-tuning and pretraining, tailored to LLaMA3 series](https://hpc-ai.com/blog/most-cost-effective-solutions-for-inference-fine-tuning-and-pretraining-tailored-to-llama3-series)
  * [2024/03] [314 Billion Parameter Grok-1 Inference Accelerated by 3.8x, Efficient and Easy-to-Use PyTorch+HuggingFace version is Here](https://hpc-ai.com/blog/314-billion-parameter-grok-1-inference-accelerated-by-3.8x-efficient-and-easy-to-use-pytorchhuggingface-version-is-here)
  * [2024/03] [Open-Sora: Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models](https://hpc-ai.com/blog/open-sora-v1.0)
  * [2024/03] [Open-Sora：Sora Replication Solution with 46% Cost Reduction, Sequence Expansion to Nearly a Million](https://hpc-ai.com/blog/open-sora)
  * [2024/01] [Inference Performance Improved by 46%, Open Source Solution Breaks the Length Limit of LLM for Multi-Round Conversations](https://hpc-ai.com/blog/Colossal-AI-SwiftInfer)
  * [2023/07] [HPC-AI Tech Raises 22 Million USD in Series A Funding](https://www.hpc-ai.tech/blog/hpc-ai-tech-raises-22-million-usd-in-series-a-funding-to-fuel-team-expansion-and-business-growth)


  <ul>
   <li><a href="#Why-Colossal-AI">Why Colossal-AI</a> </li>
   <li><a href="#Features">Features</a> </li>
   <li>
     <a href="#Colossal-AI-in-the-Real-World">Colossal-AI for Real World Applications</a>
     <ul>
       <li><a href="#Open-Sora">Open-Sora: Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models</a></li>
       <li><a href="#Colossal-LLaMA-2">Colossal-LLaMA-2: One Half-Day of Training Using a Few Hundred Dollars Yields Similar Results to Mainstream Large Models, Open-Source and Commercial-Free Domain-Specific Llm Solution</a></li>
       <li><a href="#ColossalChat">ColossalChat: An Open-Source Solution for Cloning ChatGPT With a Complete RLHF Pipeline</a></li>
       <li><a href="#AIGC">AIGC: Acceleration of Stable Diffusion</a></li>
       <li><a href="#Biomedicine">Biomedicine: Acceleration of AlphaFold Protein Structure</a></li>
     </ul>
   </li>
   <li>
     <a href="#Parallel-Training-Demo">Parallel Training Demo</a>
     <ul>
       <li><a href="#LLaMA3">LLaMA 1/2/3 </a></li>
       <li><a href="#MoE">MoE</a></li>
       <li><a href="#GPT-3">GPT-3</a></li>
       <li><a href="#GPT-2">GPT-2</a></li>
       <li><a href="#BERT">BERT</a></li>
       <li><a href="#PaLM">PaLM</a></li>
       <li><a href="#OPT">OPT</a></li>
       <li><a href="#ViT">ViT</a></li>
       <li><a href="#Recommendation-System-Models">Recommendation System Models</a></li>
     </ul>
   </li>
   <li>
     <a href="#Single-GPU-Training-Demo">Single GPU Training Demo</a>
     <ul>
       <li><a href="#GPT-2-Single">GPT-2</a></li>
       <li><a href="#PaLM-Single">PaLM</a></li>
     </ul>
   </li>
   <li>
     <a href="#Inference">Inference</a>
     <ul>
       <li><a href="#Colossal-Inference">Colossal-Inference: Large AI  Models Inference Speed Doubled</a></li>
       <li><a href="#Grok-1">Grok-1: 314B model of PyTorch + HuggingFace Inference</a></li>
       <li><a href="#SwiftInfer">SwiftInfer:Breaks the Length Limit of LLM for Multi-Round Conversations with 46% Acceleration</a></li>
     </ul>
   </li>
   <li>
     <a href="#Installation">Installation</a>
     <ul>
       <li><a href="#PyPI">PyPI</a></li>
       <li><a href="#Install-From-Source">Install From Source</a></li>
     </ul>
   </li>
   <li><a href="#Use-Docker">Use Docker</a></li>
   <li><a href="#Community">Community</a></li>
   <li><a href="#Contributing">Contributing</a></li>
   <li><a href="#Cite-Us">Cite Us</a></li>
  </ul>


  <div align="center">
     <a href="https://youtu.be/KnXSfjqkKN0">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/JamesDemmel_Colossal-AI.png" width="600" />
     </a>

     Prof. James Demmel (UC Berkeley): Colossal-AI makes training AI models efficient, easy, and scalable.
  </div>

  <p align="right">(<a href="#top">back to top</a>)</p>



  Colossal-AI provides a collection of parallel components for you. We aim to support you to write your
  distributed deep learning models just like how you write your model on your laptop. We provide user-friendly tools to kickstart
  distributed training and inference in a few lines.

  - Parallelism strategies
    - Data Parallelism
    - Pipeline Parallelism
    - 1D, [2D](https://arxiv.org/abs/2104.05343), [2.5D](https://arxiv.org/abs/2105.14500), [3D](https://arxiv.org/abs/2105.14450) Tensor Parallelism
    - [Sequence Parallelism](https://arxiv.org/abs/2105.13120)
    - [Zero Redundancy Optimizer (ZeRO)](https://arxiv.org/abs/1910.02054)
    - [Auto-Parallelism](https://arxiv.org/abs/2302.02599)

  - Heterogeneous Memory Management
    - [PatrickStar](https://arxiv.org/abs/2108.05818)

  - Friendly Usage
    - Parallelism based on the configuration file

  <p align="right">(<a href="#top">back to top</a>)</p>




  [Open-Sora](https://github.com/hpcaitech/Open-Sora)：Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models
  [[code]](https://github.com/hpcaitech/Open-Sora)
  [[blog]](https://hpc-ai.com/blog/open-sora-from-hpc-ai-tech-team-continues-open-source-generate-any-16-second-720p-hd-video-with-one-click-model-weights-ready-to-use)
  [[Model weights]](https://github.com/hpcaitech/Open-Sora?tab=readme-ov-file#model-weights)
  [[Demo]](https://github.com/hpcaitech/Open-Sora?tab=readme-ov-file#-latest-demo)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[OpenSora Image]](https://cloud.luchentech.com/doc/docs/image/open-sora/)

  <div align="center">
     <a href="https://youtu.be/ilMQpU71ddI?si=J4JSPzZ03ycYmlki">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/sora/opensora-v1.2.png" width="700" />
     </a>
  </div>

  <p align="right">(<a href="#top">back to top</a>)</p>



  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)

  - 7B: One half-day of training using a few hundred dollars yields similar results to mainstream large models, open-source and commercial-free domain-specific LLM solution.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Colossal-LLaMA-2)
  [[blog]](https://www.hpc-ai.tech/blog/one-half-day-of-training-using-a-few-hundred-dollars-yields-similar-results-to-mainstream-large-models-open-source-and-commercial-free-domain-specific-llm-solution)
  [[HuggingFace model weights]](https://huggingface.co/hpcai-tech/Colossal-LLaMA-2-7b-base)
  [[Modelscope model weights]](https://www.modelscope.cn/models/colossalai/Colossal-LLaMA-2-7b-base/summary)

  - 13B: Construct refined 13B private model with just $5000 USD.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Colossal-LLaMA-2)
  [[blog]](https://hpc-ai.com/blog/colossal-llama-2-13b)
  [[HuggingFace model weights]](https://huggingface.co/hpcai-tech/Colossal-LLaMA-2-13b-base)
  [[Modelscope model weights]](https://www.modelscope.cn/models/colossalai/Colossal-LLaMA-2-13b-base/summary)

  |              Model              |  Backbone  | Tokens Consumed |     MMLU (5-shot)    | CMMLU (5-shot)| AGIEval (5-shot) | GAOKAO (0-shot) | CEval (5-shot)  |
  | :-----------------------------: | :--------: | :-------------: | :------------------: | :-----------: | :--------------: | :-------------: | :-------------: |
  |          Baichuan-7B            |     -      |      1.2T       |    42.32 (42.30)     | 44.53 (44.02) |        38.72     |       36.74     |       42.80     |
  |       Baichuan-13B-Base         |     -      |      1.4T       |    50.51 (51.60)     | 55.73 (55.30) |        47.20     |       51.41     |       53.60     |
  |       Baichuan2-7B-Base         |     -      |      2.6T       |    46.97 (54.16)     | 57.67 (57.07) |        45.76     |       52.60     |       54.00     |
  |       Baichuan2-13B-Base        |     -      |      2.6T       |    54.84 (59.17)     | 62.62 (61.97) |        52.08     |       58.25     |       58.10     |
  |           ChatGLM-6B            |     -      |      1.0T       |    39.67 (40.63)     |   41.17 (-)   |        40.10     |       36.53     |       38.90     |
  |          ChatGLM2-6B            |     -      |      1.4T       |    44.74 (45.46)     |   49.40 (-)   |        46.36     |       45.49     |       51.70     |
  |          InternLM-7B            |     -      |      1.6T       |    46.70 (51.00)     |   52.00 (-)   |        44.77     |       61.64     |       52.80     |
  |            Qwen-7B              |     -      |      2.2T       |    54.29 (56.70)     | 56.03 (58.80) |        52.47     |       56.42     |       59.60     |
  |           Llama-2-7B            |     -      |      2.0T       |    44.47 (45.30)     |   32.97 (-)   |        32.60     |       25.46     |         -       |
  | Linly-AI/Chinese-LLaMA-2-7B-hf  | Llama-2-7B |      1.0T       |        37.43         |     29.92     |        32.00     |       27.57     |         -       |
  | wenge-research/yayi-7b-llama2   | Llama-2-7B |        -        |        38.56         |     31.52     |        30.99     |       25.95     |         -       |
  | ziqingyang/chinese-llama-2-7b   | Llama-2-7B |        -        |        33.86         |     34.69     |        34.52     |       25.18     |        34.2     |
  | TigerResearch/tigerbot-7b-base  | Llama-2-7B |      0.3T       |        43.73         |     42.04     |        37.64     |       30.61     |         -       |
  |  LinkSoul/Chinese-Llama-2-7b    | Llama-2-7B |        -        |        48.41         |     38.31     |        38.45     |       27.72     |         -       |
  |       FlagAlpha/Atom-7B         | Llama-2-7B |      0.1T       |        49.96         |     41.10     |        39.83     |       33.00     |         -       |
  | IDEA-CCNL/Ziya-LLaMA-13B-v1.1   | Llama-13B  |      0.11T      |        50.25         |     40.99     |        40.04     |       30.54     |         -       |
  |  **Colossal-LLaMA-2-7b-base**   | Llama-2-7B |   **0.0085T**   |        53.06         |     49.89     |        51.48     |       58.82     |        50.2     |
  |  **Colossal-LLaMA-2-13b-base**  | Llama-2-13B |   **0.025T**    |        56.42         |     61.80     |        54.69     |       69.53     |        60.3     |




  <div align="center">
     <a href="https://www.youtube.com/watch?v=HcTiHzApHm0">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chat/ColossalChat%20YouTube.png" width="700" />
     </a>
  </div>

  [ColossalChat](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Chat): An open-source solution for cloning [ChatGPT](https://openai.com/blog/chatgpt/) with a complete RLHF pipeline.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Chat)
  [[blog]](https://medium.com/@yangyou_berkeley/colossalchat-an-open-source-solution-for-cloning-chatgpt-with-a-complete-rlhf-pipeline-5edf08fb538b)
  [[demo]](https://www.youtube.com/watch?v=HcTiHzApHm0)
  [[tutorial]](https://www.youtube.com/watch?v=-qFBZFmOJfg)

  <p id="ColossalChat-Speed" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chat/ColossalChat%20Speed.jpg" width=450/>
  </p>

  - Up to 10 times faster for RLHF PPO Stage3 Training

  <p id="ColossalChat_scaling" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/ChatGPT%20scaling.png" width=800/>
  </p>

  - Up to 7.73 times faster for single server training and 1.42 times faster for single-GPU inference

  <p id="ColossalChat-1GPU" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/ChatGPT-1GPU.jpg" width=450/>
  </p>

  - Up to 10.3x growth in model capacity on one GPU
  - A mini demo training process requires only 1.62GB of GPU memory (any consumer-grade GPU)

  <p id="ColossalChat-LoRA" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/LoRA%20data.jpg" width=600/>
  </p>

  - Increase the capacity of the fine-tuning model by up to 3.7 times on a single GPU
  - Keep at a sufficiently high running speed

  <p align="right">(<a href="#top">back to top</a>)</p>



  Acceleration of AIGC (AI-Generated Content) models such as [Stable Diffusion v1](https://github.com/CompVis/stable-diffusion) and [Stable Diffusion v2](https://github.com/Stability-AI/stablediffusion).
  <p id="diffusion_train" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/Stable%20Diffusion%20v2.png" width=800/>
  </p>

  - [Training](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/diffusion): Reduce Stable Diffusion memory consumption by up to 5.6x and hardware cost by up to 46x (from A100 to RTX3060).

  <p id="diffusion_demo" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/DreamBooth.png" width=800/>
  </p>

  - [DreamBooth Fine-tuning](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/dreambooth): Personalize your model using just 3-5 images of the desired subject.

  <p id="inference-sd" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/Stable%20Diffusion%20Inference.jpg" width=800/>
  </p>

  - [Inference](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/diffusion): Reduce inference GPU memory consumption by 2.5x.


  <p align="right">(<a href="#top">back to top</a>)</p>


  Acceleration of [AlphaFold Protein Structure](https://alphafold.ebi.ac.uk/)

  <p id="FastFold" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/FastFold.jpg" width=800/>
  </p>

  - [FastFold](https://github.com/hpcaitech/FastFold): Accelerating training and inference on GPU Clusters, faster data processing, inference sequence containing more than 10000 residues.

  <p id="FastFold-Intel" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/data%20preprocessing%20with%20Intel.jpg" width=600/>
  </p>

  - [FastFold with Intel](https://github.com/hpcaitech/FastFold): 3x inference acceleration and 39% cost reduce.

  <p id="xTrimoMultimer" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/xTrimoMultimer_Table.jpg" width=800/>
  </p>

  - [xTrimoMultimer](https://github.com/biomap-research/xTrimoMultimer): accelerating structure prediction of protein monomers and multimer by 11x.


  <p align="right">(<a href="#top">back to top</a>)</p>



  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/LLaMA3-70B-H100.png" width=600/>
  </p>

  - 70 billion parameter LLaMA3 model training accelerated by 18%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/llama2_pretraining.png" width=600/>
  </p>

  - 70 billion parameter LLaMA2 model training accelerated by 195%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[blog]](https://www.hpc-ai.tech/blog/70b-llama2-training)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/LLaMA_pretraining.png" width=600/>
  </p>

  - 65-billion-parameter large model pretraining accelerated by 38%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[blog]](https://www.hpc-ai.tech/blog/large-model-pretraining)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/MOE_training.png" width=800/>
  </p>

  - Enhanced MoE parallelism, Open-source MoE model training can be 9 times more efficient
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/openmoe)
  [[blog]](https://www.hpc-ai.tech/blog/enhanced-moe-parallelism-open-source-moe-model-training-can-be-9-times-more-efficient)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT3-v5.png" width=700/>
  </p>

  - Save 50% GPU resources and 10.7% acceleration


  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2.png" width=800/>

  - 11x lower GPU memory consumption, and superlinear scaling efficiency with Tensor Parallelism

  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/(updated)GPT-2.png" width=800>

  - 24x larger model size on the same hardware
  - over 3x acceleration

  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/BERT.png" width=800/>

  - 2x faster training, or 50% longer sequence length


  - [PaLM-colossalai](https://github.com/hpcaitech/PaLM-colossalai): Scalable implementation of Google's Pathways Language Model ([PaLM](https://ai.googleblog.com/2022/04/pathways-language-model-palm-scaling-to.html)).


  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/OPT_update.png" width=800/>

  - [Open Pretrained Transformer (OPT)](https://github.com/facebookresearch/metaseq), a 175-Billion parameter AI language model released by Meta, which stimulates AI programmers to perform various downstream tasks and application deployments because of public pre-trained model weights.
  - 45% speedup fine-tuning OPT at low cost in lines. [[Example]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/opt) [[Online Serving]](https://colossalai.org/docs/advanced_tutorials/opt_service)

  Please visit our [documentation](https://www.colossalai.org/) and [examples](https://github.com/hpcaitech/ColossalAI/tree/main/examples) for more details.


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/ViT.png" width="450" />
  </p>

  - 14x larger batch size, and 5x faster training for Tensor Parallelism = 64


  - [Cached Embedding](https://github.com/hpcaitech/CachedEmbedding), utilize software cache to train larger embedding tables with a smaller GPU memory budget.

  <p align="right">(<a href="#top">back to top</a>)</p>




  <p id="GPT-2-Single" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2-GPU1.png" width=450/>
  </p>

  - 20x larger model size on the same hardware

  <p id="GPT-2-NVME" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2-NVME.png" width=800/>
  </p>

  - 120x larger model size on the same hardware (RTX 3080)


  <p id="PaLM-Single" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/PaLM-GPU1.png" width=450/>
  </p>

  - 34x larger model size on the same hardware

  <p align="right">(<a href="#top">back to top</a>)</p>




  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/inference/colossal-inference-v1-1.png" width=1000/>
  </p>

  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/inference/colossal-inference-v1-2.png" width=1000/>
  </p>

   - Large AI models inference speed doubled, compared to the offline inference performance of vLLM in some cases.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/colossalai/inference)
  [[blog]](https://hpc-ai.com/blog/colossal-inference)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)


  <p id="Grok-1" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/grok-1-inference.jpg" width=600/>
  </p>

   - 314 Billion Parameter Grok-1 Inference Accelerated by 3.8x, an easy-to-use Python + PyTorch + HuggingFace version for Inference.

  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/grok-1)
  [[blog]](https://hpc-ai.com/blog/314-billion-parameter-grok-1-inference-accelerated-by-3.8x-efficient-and-easy-to-use-pytorchhuggingface-version-is-here)
  [[HuggingFace Grok-1 PyTorch model weights]](https://huggingface.co/hpcai-tech/grok-1)
  [[ModelScope Grok-1 PyTorch model weights]](https://www.modelscope.cn/models/colossalai/grok-1-pytorch/summary)


  <p id="SwiftInfer" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/SwiftInfer.jpg" width=800/>
  </p>

  - [SwiftInfer](https://github.com/hpcaitech/SwiftInfer): Inference performance improved by 46%, open source solution breaks the length limit of LLM for multi-round conversations

  <p align="right">(<a href="#top">back to top</a>)</p>



  Requirements:
  - PyTorch >= 2.2
  - Python >= 3.7
  - CUDA >= 11.0
  - [NVIDIA GPU Compute Capability](https://developer.nvidia.com/cuda-gpus) >= 7.0 (V100/RTX20 and higher)
  - Linux OS

  If you encounter any problem with installation, you may want to raise an [issue](https://github.com/hpcaitech/ColossalAI/issues/new/choose) in this repository.



  You can easily install Colossal-AI with the following command. **By default, we do not build PyTorch extensions during installation.**

  ```bash
  pip install colossalai
  ```

  **Note: only Linux is supported for now.**

  However, if you want to build the PyTorch extensions during installation, you can set `BUILD_EXT=1`.

  ```bash
  BUILD_EXT=1 pip install colossalai
  ```

  **Otherwise, CUDA kernels will be built during runtime when you actually need them.**

  We also keep releasing the nightly version to PyPI every week. This allows you to access the unreleased features and bug fixes in the main branch.
  Installation can be made via

  ```bash
  pip install colossalai-nightly
  ```



  > The version of Colossal-AI will be in line with the main branch of the repository. Feel free to raise an issue if you encounter any problems. :)

  ```shell
  git clone https://github.com/hpcaitech/ColossalAI.git
  cd ColossalAI


  pip install .
  ```

  By default, we do not compile CUDA/C++ kernels. ColossalAI will build them during runtime.
  If you want to install and enable CUDA kernel fusion (compulsory installation when using fused optimizer):

  ```shell
  BUILD_EXT=1 pip install .
  ```

  For Users with CUDA 10.2, you can still build ColossalAI from source. However, you need to manually download the cub library and copy it to the corresponding directory.

  ```bash

  git clone https://github.com/hpcaitech/ColossalAI.git
  cd ColossalAI


  wget https://github.com/NVIDIA/cub/archive/refs/tags/1.8.0.zip
  unzip 1.8.0.zip
  cp -r cub-1.8.0/cub/ colossalai/kernel/cuda_native/csrc/kernels/include/


  BUILD_EXT=1 pip install .
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>





  You can directly pull the docker image from our [DockerHub page](https://hub.docker.com/r/hpcaitech/colossalai). The image is automatically uploaded upon release.




  Run the following command to build a docker image from Dockerfile provided.

  > Building Colossal-AI from scratch requires GPU support, you need to use Nvidia Docker Runtime as the default when doing `docker build`. More details can be found [here](https://stackoverflow.com/questions/59691207/docker-build-with-nvidia-runtime).
  > We recommend you install Colossal-AI from our [project page](https://www.colossalai.org) directly.


  ```bash
  cd ColossalAI
  docker build -t colossalai ./docker
  ```

  Run the following command to start the docker container in interactive mode.

  ```bash
  docker run -ti --gpus all --rm --ipc=host colossalai bash
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>



  Join the Colossal-AI community on [Forum](https://github.com/hpcaitech/ColossalAI/discussions),
  [Slack](https://join.slack.com/t/colossalaiworkspace/shared_invite/zt-z7b26eeb-CBp7jouvu~r0~lcFzX832w),
  and [WeChat(微信)](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/WeChat.png "qrcode") to share your suggestions, feedback, and questions with our engineering team.


  Referring to the successful attempts of [BLOOM](https://bigscience.huggingface.co/) and [Stable Diffusion](https://en.wikipedia.org/wiki/Stable_Diffusion), any and all developers and partners with computing powers, datasets, models are welcome to join and build the Colossal-AI community, making efforts towards the era of big AI models!

  You may contact us or participate in the following ways:
  1. [Leaving a Star ⭐](https://github.com/hpcaitech/ColossalAI/stargazers) to show your like and support. Thanks!
  2. Posting an [issue](https://github.com/hpcaitech/ColossalAI/issues/new/choose), or submitting a PR on GitHub follow the guideline in [Contributing](https://github.com/hpcaitech/ColossalAI/blob/main/CONTRIBUTING.md)
  3. Send your official proposal to email contact@hpcaitech.com

  Thanks so much to all of our amazing contributors!

  <a href="https://github.com/hpcaitech/ColossalAI/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=hpcaitech/ColossalAI"  width="800px"/>
  </a>


  <p align="right">(<a href="#top">back to top</a>)</p>




  We leverage the power of [GitHub Actions](https://github.com/features/actions) to automate our development, release and deployment workflows. Please check out this [documentation](.github/workflows/README.md) on how the automated workflows are operated.




  This project is inspired by some related projects (some by our team and some by other organizations). We would like to credit these amazing projects as listed in the [Reference List](./docs/REFERENCE.md).

  To cite this project, you can use the following BibTeX citation.

  ```
  @inproceedings{10.1145/3605573.3605613,
  author = {Li, Shenggui and Liu, Hongxin and Bian, Zhengda and Fang, Jiarui and Huang, Haichen and Liu, Yuliang and Wang, Boxiang and You, Yang},
  title = {Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training},
  year = {2023},
  isbn = {9798400708435},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3605573.3605613},
  doi = {10.1145/3605573.3605613},
  abstract = {The success of Transformer models has pushed the deep learning model scale to billions of parameters, but the memory limitation of a single GPU has led to an urgent need for training on multi-GPU clusters. However, the best practice for choosing the optimal parallel strategy is still lacking, as it requires domain expertise in both deep learning and parallel computing. The Colossal-AI system addressed the above challenge by introducing a unified interface to scale your sequential code of model training to distributed environments. It supports parallel training methods such as data, pipeline, tensor, and sequence parallelism and is integrated with heterogeneous training and zero redundancy optimizer. Compared to the baseline system, Colossal-AI can achieve up to 2.76 times training speedup on large-scale models.},
  booktitle = {Proceedings of the 52nd International Conference on Parallel Processing},
  pages = {766–775},
  numpages = {10},
  keywords = {datasets, gaze detection, text tagging, neural networks},
  location = {Salt Lake City, UT, USA},
  series = {ICPP '23}
  }
  ```

  Colossal-AI has been accepted as official tutorial by top conferences [NeurIPS](https://nips.cc/), [SC](https://sc22.supercomputing.org/), [AAAI](https://aaai.org/Conferences/AAAI-23/),
  [PPoPP](https://ppopp23.sigplan.org/), [CVPR](https://cvpr2023.thecvf.com/), [ISC](https://www.isc-hpc.com/), [NVIDIA GTC](https://www.nvidia.com/en-us/on-demand/session/gtcspring23-S51482/) ,etc.

  <p align="right">(<a href="#top">back to top</a>)</p>


pkgId: 37036f4a0bc73adf2de729a53a7f780e2eb23499ae94d2e845b08cd4a7e8717a
name: python-colossalai
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: An integrated large-scale model training system with efficient parallelization techniques
url: https://www.colossalai.org
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colossalai-0.4.6-1.src.rpm
checksum_type: sha256
description:
  <div id="top" align="center">

     [![logo](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/colossal-ai_logo_vertical.png)](https://www.colossalai.org/)

     Colossal-AI: Making large AI models cheaper, faster, and more accessible

     <h3> <a href="https://arxiv.org/abs/2110.14883"> Paper </a> |
     <a href="https://www.colossalai.org/"> Documentation </a> |
     <a href="https://github.com/hpcaitech/ColossalAI/tree/main/examples"> Examples </a> |
     <a href="https://github.com/hpcaitech/ColossalAI/discussions"> Forum </a> |
     <a href="https://cloud.luchentech.com/">GPU Cloud Playground </a> |
     <a href="https://hpc-ai.com/blog"> Blog </a></h3>

     [![GitHub Repo stars](https://img.shields.io/github/stars/hpcaitech/ColossalAI?style=social)](https://github.com/hpcaitech/ColossalAI/stargazers)
     [![Build](https://github.com/hpcaitech/ColossalAI/actions/workflows/build_on_schedule.yml/badge.svg)](https://github.com/hpcaitech/ColossalAI/actions/workflows/build_on_schedule.yml)
     [![Documentation](https://readthedocs.org/projects/colossalai/badge/?version=latest)](https://colossalai.readthedocs.io/en/latest/?badge=latest)
     [![CodeFactor](https://www.codefactor.io/repository/github/hpcaitech/colossalai/badge)](https://www.codefactor.io/repository/github/hpcaitech/colossalai)
     [![HuggingFace badge](https://img.shields.io/badge/%F0%9F%A4%97HuggingFace-Join-yellow)](https://huggingface.co/hpcai-tech)
     [![slack badge](https://img.shields.io/badge/Slack-join-blueviolet?logo=slack&amp)](https://github.com/hpcaitech/public_assets/tree/main/colossalai/contact/slack)
     [![WeChat badge](https://img.shields.io/badge/微信-加入-green?logo=wechat&amp)](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/WeChat.png)


     | [English](README.md) | [中文](docs/README-zh-Hans.md) |

  </div>



  For a limited time, you can access an H100 Server for just $1! This is your chance to leverage premium GPU power at an unbeatable price.
  Plus, when you refer a friend, you’ll receive 20% cashback or compute credits equal to 100% of their top-up!

  Our platform offers on-demand premium compute, ensuring safe, permanent data storage even after stopping your instance.
  Don’t miss this incredible opportunity to accelerate your AI projects!

  Unlock premium GPUs and register now at [HPC-AI.COM](https://hpc-ai.com) to receive $10!

  Special Bonuses:

  * Top up $1,000 and receive 300 credits
  * Top up $500 and receive 100 credits

  <div align="center">
     <a href="https://youtu.be/ilMQpU71ddI?si=J4JSPzZ03ycYmlki">
     <img src="https://github.com/hpcaitech/public_assets/blob/main/colossalai/img/HPCAICOM241010.jpg" width="700" />
     </a>
  </div>



  * [2024/10] [How to build a low-cost Sora-like app? Solutions for you](https://company.hpc-ai.com/blog/how-to-build-a-low-cost-sora-like-app-solutions-for-you)
  * [2024/09] [Singapore Startup HPC-AI Tech Secures 50 Million USD in Series A Funding to Build the Video Generation AI Model and GPU Platform](https://company.hpc-ai.com/blog/singapore-startup-hpc-ai-tech-secures-50-million-usd-in-series-a-funding-to-build-the-video-generation-ai-model-and-gpu-platform)
  * [2024/09] [Reducing AI Large Model Training Costs by 30% Requires Just a Single Line of Code From FP8 Mixed Precision Training Upgrades](https://company.hpc-ai.com/blog/reducing-ai-large-model-training-costs-by-30-requires-just-a-single-line-of-code-from-fp8-mixed-precision-training-upgrades)
  * [2024/06] [Open-Sora Continues Open Source: Generate Any 16-Second 720p HD Video with One Click, Model Weights Ready to Use](https://hpc-ai.com/blog/open-sora-from-hpc-ai-tech-team-continues-open-source-generate-any-16-second-720p-hd-video-with-one-click-model-weights-ready-to-use)
  * [2024/05] [Large AI Models Inference Speed Doubled, Colossal-Inference Open Source Release](https://hpc-ai.com/blog/colossal-inference)
  * [2024/04] [Open-Sora Unveils Major Upgrade: Embracing Open Source with Single-Shot 16-Second Video Generation and 720p Resolution](https://hpc-ai.com/blog/open-soras-comprehensive-upgrade-unveiled-embracing-16-second-video-generation-and-720p-resolution-in-open-source)
  * [2024/04] [Most cost-effective solutions for inference, fine-tuning and pretraining, tailored to LLaMA3 series](https://hpc-ai.com/blog/most-cost-effective-solutions-for-inference-fine-tuning-and-pretraining-tailored-to-llama3-series)


  <ul>
   <li><a href="#Why-Colossal-AI">Why Colossal-AI</a> </li>
   <li><a href="#Features">Features</a> </li>
   <li>
     <a href="#Colossal-AI-in-the-Real-World">Colossal-AI for Real World Applications</a>
     <ul>
       <li><a href="#Open-Sora">Open-Sora: Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models</a></li>
       <li><a href="#Colossal-LLaMA-2">Colossal-LLaMA-2: One Half-Day of Training Using a Few Hundred Dollars Yields Similar Results to Mainstream Large Models, Open-Source and Commercial-Free Domain-Specific Llm Solution</a></li>
       <li><a href="#ColossalChat">ColossalChat: An Open-Source Solution for Cloning ChatGPT With a Complete RLHF Pipeline</a></li>
       <li><a href="#AIGC">AIGC: Acceleration of Stable Diffusion</a></li>
       <li><a href="#Biomedicine">Biomedicine: Acceleration of AlphaFold Protein Structure</a></li>
     </ul>
   </li>
   <li>
     <a href="#Parallel-Training-Demo">Parallel Training Demo</a>
     <ul>
       <li><a href="#LLaMA3">LLaMA 1/2/3 </a></li>
       <li><a href="#MoE">MoE</a></li>
       <li><a href="#GPT-3">GPT-3</a></li>
       <li><a href="#GPT-2">GPT-2</a></li>
       <li><a href="#BERT">BERT</a></li>
       <li><a href="#PaLM">PaLM</a></li>
       <li><a href="#OPT">OPT</a></li>
       <li><a href="#ViT">ViT</a></li>
       <li><a href="#Recommendation-System-Models">Recommendation System Models</a></li>
     </ul>
   </li>
   <li>
     <a href="#Single-GPU-Training-Demo">Single GPU Training Demo</a>
     <ul>
       <li><a href="#GPT-2-Single">GPT-2</a></li>
       <li><a href="#PaLM-Single">PaLM</a></li>
     </ul>
   </li>
   <li>
     <a href="#Inference">Inference</a>
     <ul>
       <li><a href="#Colossal-Inference">Colossal-Inference: Large AI  Models Inference Speed Doubled</a></li>
       <li><a href="#Grok-1">Grok-1: 314B model of PyTorch + HuggingFace Inference</a></li>
       <li><a href="#SwiftInfer">SwiftInfer:Breaks the Length Limit of LLM for Multi-Round Conversations with 46% Acceleration</a></li>
     </ul>
   </li>
   <li>
     <a href="#Installation">Installation</a>
     <ul>
       <li><a href="#PyPI">PyPI</a></li>
       <li><a href="#Install-From-Source">Install From Source</a></li>
     </ul>
   </li>
   <li><a href="#Use-Docker">Use Docker</a></li>
   <li><a href="#Community">Community</a></li>
   <li><a href="#Contributing">Contributing</a></li>
   <li><a href="#Cite-Us">Cite Us</a></li>
  </ul>


  <div align="center">
     <a href="https://youtu.be/KnXSfjqkKN0">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/JamesDemmel_Colossal-AI.png" width="600" />
     </a>

     Prof. James Demmel (UC Berkeley): Colossal-AI makes training AI models efficient, easy, and scalable.
  </div>

  <p align="right">(<a href="#top">back to top</a>)</p>



  Colossal-AI provides a collection of parallel components for you. We aim to support you to write your
  distributed deep learning models just like how you write your model on your laptop. We provide user-friendly tools to kickstart
  distributed training and inference in a few lines.

  - Parallelism strategies
    - Data Parallelism
    - Pipeline Parallelism
    - 1D, [2D](https://arxiv.org/abs/2104.05343), [2.5D](https://arxiv.org/abs/2105.14500), [3D](https://arxiv.org/abs/2105.14450) Tensor Parallelism
    - [Sequence Parallelism](https://arxiv.org/abs/2105.13120)
    - [Zero Redundancy Optimizer (ZeRO)](https://arxiv.org/abs/1910.02054)
    - [Auto-Parallelism](https://arxiv.org/abs/2302.02599)

  - Heterogeneous Memory Management
    - [PatrickStar](https://arxiv.org/abs/2108.05818)

  - Friendly Usage
    - Parallelism based on the configuration file

  <p align="right">(<a href="#top">back to top</a>)</p>




  [Open-Sora](https://github.com/hpcaitech/Open-Sora)：Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models
  [[code]](https://github.com/hpcaitech/Open-Sora)
  [[blog]](https://hpc-ai.com/blog/open-sora-from-hpc-ai-tech-team-continues-open-source-generate-any-16-second-720p-hd-video-with-one-click-model-weights-ready-to-use)
  [[Model weights]](https://github.com/hpcaitech/Open-Sora?tab=readme-ov-file#model-weights)
  [[Demo]](https://github.com/hpcaitech/Open-Sora?tab=readme-ov-file#-latest-demo)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[OpenSora Image]](https://cloud.luchentech.com/doc/docs/image/open-sora/)

  <div align="center">
     <a href="https://youtu.be/ilMQpU71ddI?si=J4JSPzZ03ycYmlki">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/sora/opensora-v1.2.png" width="700" />
     </a>
  </div>

  <p align="right">(<a href="#top">back to top</a>)</p>



  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)

  - 7B: One half-day of training using a few hundred dollars yields similar results to mainstream large models, open-source and commercial-free domain-specific LLM solution.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Colossal-LLaMA-2)
  [[blog]](https://www.hpc-ai.tech/blog/one-half-day-of-training-using-a-few-hundred-dollars-yields-similar-results-to-mainstream-large-models-open-source-and-commercial-free-domain-specific-llm-solution)
  [[HuggingFace model weights]](https://huggingface.co/hpcai-tech/Colossal-LLaMA-2-7b-base)
  [[Modelscope model weights]](https://www.modelscope.cn/models/colossalai/Colossal-LLaMA-2-7b-base/summary)

  - 13B: Construct refined 13B private model with just $5000 USD.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Colossal-LLaMA-2)
  [[blog]](https://hpc-ai.com/blog/colossal-llama-2-13b)
  [[HuggingFace model weights]](https://huggingface.co/hpcai-tech/Colossal-LLaMA-2-13b-base)
  [[Modelscope model weights]](https://www.modelscope.cn/models/colossalai/Colossal-LLaMA-2-13b-base/summary)

  |              Model              |  Backbone  | Tokens Consumed |     MMLU (5-shot)    | CMMLU (5-shot)| AGIEval (5-shot) | GAOKAO (0-shot) | CEval (5-shot)  |
  | :-----------------------------: | :--------: | :-------------: | :------------------: | :-----------: | :--------------: | :-------------: | :-------------: |
  |          Baichuan-7B            |     -      |      1.2T       |    42.32 (42.30)     | 44.53 (44.02) |        38.72     |       36.74     |       42.80     |
  |       Baichuan-13B-Base         |     -      |      1.4T       |    50.51 (51.60)     | 55.73 (55.30) |        47.20     |       51.41     |       53.60     |
  |       Baichuan2-7B-Base         |     -      |      2.6T       |    46.97 (54.16)     | 57.67 (57.07) |        45.76     |       52.60     |       54.00     |
  |       Baichuan2-13B-Base        |     -      |      2.6T       |    54.84 (59.17)     | 62.62 (61.97) |        52.08     |       58.25     |       58.10     |
  |           ChatGLM-6B            |     -      |      1.0T       |    39.67 (40.63)     |   41.17 (-)   |        40.10     |       36.53     |       38.90     |
  |          ChatGLM2-6B            |     -      |      1.4T       |    44.74 (45.46)     |   49.40 (-)   |        46.36     |       45.49     |       51.70     |
  |          InternLM-7B            |     -      |      1.6T       |    46.70 (51.00)     |   52.00 (-)   |        44.77     |       61.64     |       52.80     |
  |            Qwen-7B              |     -      |      2.2T       |    54.29 (56.70)     | 56.03 (58.80) |        52.47     |       56.42     |       59.60     |
  |           Llama-2-7B            |     -      |      2.0T       |    44.47 (45.30)     |   32.97 (-)   |        32.60     |       25.46     |         -       |
  | Linly-AI/Chinese-LLaMA-2-7B-hf  | Llama-2-7B |      1.0T       |        37.43         |     29.92     |        32.00     |       27.57     |         -       |
  | wenge-research/yayi-7b-llama2   | Llama-2-7B |        -        |        38.56         |     31.52     |        30.99     |       25.95     |         -       |
  | ziqingyang/chinese-llama-2-7b   | Llama-2-7B |        -        |        33.86         |     34.69     |        34.52     |       25.18     |        34.2     |
  | TigerResearch/tigerbot-7b-base  | Llama-2-7B |      0.3T       |        43.73         |     42.04     |        37.64     |       30.61     |         -       |
  |  LinkSoul/Chinese-Llama-2-7b    | Llama-2-7B |        -        |        48.41         |     38.31     |        38.45     |       27.72     |         -       |
  |       FlagAlpha/Atom-7B         | Llama-2-7B |      0.1T       |        49.96         |     41.10     |        39.83     |       33.00     |         -       |
  | IDEA-CCNL/Ziya-LLaMA-13B-v1.1   | Llama-13B  |      0.11T      |        50.25         |     40.99     |        40.04     |       30.54     |         -       |
  |  **Colossal-LLaMA-2-7b-base**   | Llama-2-7B |   **0.0085T**   |        53.06         |     49.89     |        51.48     |       58.82     |        50.2     |
  |  **Colossal-LLaMA-2-13b-base**  | Llama-2-13B |   **0.025T**    |        56.42         |     61.80     |        54.69     |       69.53     |        60.3     |




  <div align="center">
     <a href="https://www.youtube.com/watch?v=HcTiHzApHm0">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chat/ColossalChat%20YouTube.png" width="700" />
     </a>
  </div>

  [ColossalChat](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Chat): An open-source solution for cloning [ChatGPT](https://openai.com/blog/chatgpt/) with a complete RLHF pipeline.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Chat)
  [[blog]](https://medium.com/@yangyou_berkeley/colossalchat-an-open-source-solution-for-cloning-chatgpt-with-a-complete-rlhf-pipeline-5edf08fb538b)
  [[demo]](https://www.youtube.com/watch?v=HcTiHzApHm0)
  [[tutorial]](https://www.youtube.com/watch?v=-qFBZFmOJfg)

  <p id="ColossalChat-Speed" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chat/ColossalChat%20Speed.jpg" width=450/>
  </p>

  - Up to 10 times faster for RLHF PPO Stage3 Training

  <p id="ColossalChat_scaling" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/ChatGPT%20scaling.png" width=800/>
  </p>

  - Up to 7.73 times faster for single server training and 1.42 times faster for single-GPU inference

  <p id="ColossalChat-1GPU" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/ChatGPT-1GPU.jpg" width=450/>
  </p>

  - Up to 10.3x growth in model capacity on one GPU
  - A mini demo training process requires only 1.62GB of GPU memory (any consumer-grade GPU)

  <p id="ColossalChat-LoRA" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/LoRA%20data.jpg" width=600/>
  </p>

  - Increase the capacity of the fine-tuning model by up to 3.7 times on a single GPU
  - Keep at a sufficiently high running speed

  <p align="right">(<a href="#top">back to top</a>)</p>



  Acceleration of AIGC (AI-Generated Content) models such as [Stable Diffusion v1](https://github.com/CompVis/stable-diffusion) and [Stable Diffusion v2](https://github.com/Stability-AI/stablediffusion).
  <p id="diffusion_train" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/Stable%20Diffusion%20v2.png" width=800/>
  </p>

  - [Training](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/diffusion): Reduce Stable Diffusion memory consumption by up to 5.6x and hardware cost by up to 46x (from A100 to RTX3060).

  <p id="diffusion_demo" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/DreamBooth.png" width=800/>
  </p>

  - [DreamBooth Fine-tuning](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/dreambooth): Personalize your model using just 3-5 images of the desired subject.

  <p id="inference-sd" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/Stable%20Diffusion%20Inference.jpg" width=800/>
  </p>

  - [Inference](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/diffusion): Reduce inference GPU memory consumption by 2.5x.


  <p align="right">(<a href="#top">back to top</a>)</p>


  Acceleration of [AlphaFold Protein Structure](https://alphafold.ebi.ac.uk/)

  <p id="FastFold" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/FastFold.jpg" width=800/>
  </p>

  - [FastFold](https://github.com/hpcaitech/FastFold): Accelerating training and inference on GPU Clusters, faster data processing, inference sequence containing more than 10000 residues.

  <p id="FastFold-Intel" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/data%20preprocessing%20with%20Intel.jpg" width=600/>
  </p>

  - [FastFold with Intel](https://github.com/hpcaitech/FastFold): 3x inference acceleration and 39% cost reduce.

  <p id="xTrimoMultimer" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/xTrimoMultimer_Table.jpg" width=800/>
  </p>

  - [xTrimoMultimer](https://github.com/biomap-research/xTrimoMultimer): accelerating structure prediction of protein monomers and multimer by 11x.


  <p align="right">(<a href="#top">back to top</a>)</p>



  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/LLaMA3-70B-H100.png" width=600/>
  </p>

  - 70 billion parameter LLaMA3 model training accelerated by 18%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/llama2_pretraining.png" width=600/>
  </p>

  - 70 billion parameter LLaMA2 model training accelerated by 195%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[blog]](https://www.hpc-ai.tech/blog/70b-llama2-training)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/LLaMA_pretraining.png" width=600/>
  </p>

  - 65-billion-parameter large model pretraining accelerated by 38%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[blog]](https://www.hpc-ai.tech/blog/large-model-pretraining)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/MOE_training.png" width=800/>
  </p>

  - Enhanced MoE parallelism, Open-source MoE model training can be 9 times more efficient
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/openmoe)
  [[blog]](https://www.hpc-ai.tech/blog/enhanced-moe-parallelism-open-source-moe-model-training-can-be-9-times-more-efficient)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT3-v5.png" width=700/>
  </p>

  - Save 50% GPU resources and 10.7% acceleration


  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2.png" width=800/>

  - 11x lower GPU memory consumption, and superlinear scaling efficiency with Tensor Parallelism

  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/(updated)GPT-2.png" width=800>

  - 24x larger model size on the same hardware
  - over 3x acceleration

  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/BERT.png" width=800/>

  - 2x faster training, or 50% longer sequence length


  - [PaLM-colossalai](https://github.com/hpcaitech/PaLM-colossalai): Scalable implementation of Google's Pathways Language Model ([PaLM](https://ai.googleblog.com/2022/04/pathways-language-model-palm-scaling-to.html)).


  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/OPT_update.png" width=800/>

  - [Open Pretrained Transformer (OPT)](https://github.com/facebookresearch/metaseq), a 175-Billion parameter AI language model released by Meta, which stimulates AI programmers to perform various downstream tasks and application deployments because of public pre-trained model weights.
  - 45% speedup fine-tuning OPT at low cost in lines. [[Example]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/opt) [[Online Serving]](https://colossalai.org/docs/advanced_tutorials/opt_service)

  Please visit our [documentation](https://www.colossalai.org/) and [examples](https://github.com/hpcaitech/ColossalAI/tree/main/examples) for more details.


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/ViT.png" width="450" />
  </p>

  - 14x larger batch size, and 5x faster training for Tensor Parallelism = 64


  - [Cached Embedding](https://github.com/hpcaitech/CachedEmbedding), utilize software cache to train larger embedding tables with a smaller GPU memory budget.

  <p align="right">(<a href="#top">back to top</a>)</p>




  <p id="GPT-2-Single" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2-GPU1.png" width=450/>
  </p>

  - 20x larger model size on the same hardware

  <p id="GPT-2-NVME" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2-NVME.png" width=800/>
  </p>

  - 120x larger model size on the same hardware (RTX 3080)


  <p id="PaLM-Single" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/PaLM-GPU1.png" width=450/>
  </p>

  - 34x larger model size on the same hardware

  <p align="right">(<a href="#top">back to top</a>)</p>




  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/inference/colossal-inference-v1-1.png" width=1000/>
  </p>

  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/inference/colossal-inference-v1-2.png" width=1000/>
  </p>

   - Large AI models inference speed doubled, compared to the offline inference performance of vLLM in some cases.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/colossalai/inference)
  [[blog]](https://hpc-ai.com/blog/colossal-inference)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)


  <p id="Grok-1" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/grok-1-inference.jpg" width=600/>
  </p>

   - 314 Billion Parameter Grok-1 Inference Accelerated by 3.8x, an easy-to-use Python + PyTorch + HuggingFace version for Inference.

  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/grok-1)
  [[blog]](https://hpc-ai.com/blog/314-billion-parameter-grok-1-inference-accelerated-by-3.8x-efficient-and-easy-to-use-pytorchhuggingface-version-is-here)
  [[HuggingFace Grok-1 PyTorch model weights]](https://huggingface.co/hpcai-tech/grok-1)
  [[ModelScope Grok-1 PyTorch model weights]](https://www.modelscope.cn/models/colossalai/grok-1-pytorch/summary)


  <p id="SwiftInfer" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/SwiftInfer.jpg" width=800/>
  </p>

  - [SwiftInfer](https://github.com/hpcaitech/SwiftInfer): Inference performance improved by 46%, open source solution breaks the length limit of LLM for multi-round conversations

  <p align="right">(<a href="#top">back to top</a>)</p>



  Requirements:
  - PyTorch >= 2.2
  - Python >= 3.7
  - CUDA >= 11.0
  - [NVIDIA GPU Compute Capability](https://developer.nvidia.com/cuda-gpus) >= 7.0 (V100/RTX20 and higher)
  - Linux OS

  If you encounter any problem with installation, you may want to raise an [issue](https://github.com/hpcaitech/ColossalAI/issues/new/choose) in this repository.



  You can easily install Colossal-AI with the following command. **By default, we do not build PyTorch extensions during installation.**

  ```bash
  pip install colossalai
  ```

  **Note: only Linux is supported for now.**

  However, if you want to build the PyTorch extensions during installation, you can set `BUILD_EXT=1`.

  ```bash
  BUILD_EXT=1 pip install colossalai
  ```

  **Otherwise, CUDA kernels will be built during runtime when you actually need them.**

  We also keep releasing the nightly version to PyPI every week. This allows you to access the unreleased features and bug fixes in the main branch.
  Installation can be made via

  ```bash
  pip install colossalai-nightly
  ```



  > The version of Colossal-AI will be in line with the main branch of the repository. Feel free to raise an issue if you encounter any problems. :)

  ```shell
  git clone https://github.com/hpcaitech/ColossalAI.git
  cd ColossalAI


  pip install .
  ```

  By default, we do not compile CUDA/C++ kernels. ColossalAI will build them during runtime.
  If you want to install and enable CUDA kernel fusion (compulsory installation when using fused optimizer):

  ```shell
  BUILD_EXT=1 pip install .
  ```

  For Users with CUDA 10.2, you can still build ColossalAI from source. However, you need to manually download the cub library and copy it to the corresponding directory.

  ```bash

  git clone https://github.com/hpcaitech/ColossalAI.git
  cd ColossalAI


  wget https://github.com/NVIDIA/cub/archive/refs/tags/1.8.0.zip
  unzip 1.8.0.zip
  cp -r cub-1.8.0/cub/ colossalai/kernel/cuda_native/csrc/kernels/include/


  BUILD_EXT=1 pip install .
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>





  You can directly pull the docker image from our [DockerHub page](https://hub.docker.com/r/hpcaitech/colossalai). The image is automatically uploaded upon release.




  Run the following command to build a docker image from Dockerfile provided.

  > Building Colossal-AI from scratch requires GPU support, you need to use Nvidia Docker Runtime as the default when doing `docker build`. More details can be found [here](https://stackoverflow.com/questions/59691207/docker-build-with-nvidia-runtime).
  > We recommend you install Colossal-AI from our [project page](https://www.colossalai.org) directly.


  ```bash
  cd ColossalAI
  docker build -t colossalai ./docker
  ```

  Run the following command to start the docker container in interactive mode.

  ```bash
  docker run -ti --gpus all --rm --ipc=host colossalai bash
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>



  Join the Colossal-AI community on [Forum](https://github.com/hpcaitech/ColossalAI/discussions),
  [Slack](https://join.slack.com/t/colossalaiworkspace/shared_invite/zt-z7b26eeb-CBp7jouvu~r0~lcFzX832w),
  and [WeChat(微信)](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/WeChat.png "qrcode") to share your suggestions, feedback, and questions with our engineering team.


  Referring to the successful attempts of [BLOOM](https://bigscience.huggingface.co/) and [Stable Diffusion](https://en.wikipedia.org/wiki/Stable_Diffusion), any and all developers and partners with computing powers, datasets, models are welcome to join and build the Colossal-AI community, making efforts towards the era of big AI models!

  You may contact us or participate in the following ways:
  1. [Leaving a Star ⭐](https://github.com/hpcaitech/ColossalAI/stargazers) to show your like and support. Thanks!
  2. Posting an [issue](https://github.com/hpcaitech/ColossalAI/issues/new/choose), or submitting a PR on GitHub follow the guideline in [Contributing](https://github.com/hpcaitech/ColossalAI/blob/main/CONTRIBUTING.md)
  3. Send your official proposal to email contact@hpcaitech.com

  Thanks so much to all of our amazing contributors!

  <a href="https://github.com/hpcaitech/ColossalAI/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=hpcaitech/ColossalAI"  width="800px"/>
  </a>


  <p align="right">(<a href="#top">back to top</a>)</p>




  We leverage the power of [GitHub Actions](https://github.com/features/actions) to automate our development, release and deployment workflows. Please check out this [documentation](.github/workflows/README.md) on how the automated workflows are operated.




  This project is inspired by some related projects (some by our team and some by other organizations). We would like to credit these amazing projects as listed in the [Reference List](./docs/REFERENCE.md).

  To cite this project, you can use the following BibTeX citation.

  ```
  @inproceedings{10.1145/3605573.3605613,
  author = {Li, Shenggui and Liu, Hongxin and Bian, Zhengda and Fang, Jiarui and Huang, Haichen and Liu, Yuliang and Wang, Boxiang and You, Yang},
  title = {Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training},
  year = {2023},
  isbn = {9798400708435},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3605573.3605613},
  doi = {10.1145/3605573.3605613},
  abstract = {The success of Transformer models has pushed the deep learning model scale to billions of parameters, but the memory limitation of a single GPU has led to an urgent need for training on multi-GPU clusters. However, the best practice for choosing the optimal parallel strategy is still lacking, as it requires domain expertise in both deep learning and parallel computing. The Colossal-AI system addressed the above challenge by introducing a unified interface to scale your sequential code of model training to distributed environments. It supports parallel training methods such as data, pipeline, tensor, and sequence parallelism and is integrated with heterogeneous training and zero redundancy optimizer. Compared to the baseline system, Colossal-AI can achieve up to 2.76 times training speedup on large-scale models.},
  booktitle = {Proceedings of the 52nd International Conference on Parallel Processing},
  pages = {766–775},
  numpages = {10},
  keywords = {datasets, gaze detection, text tagging, neural networks},
  location = {Salt Lake City, UT, USA},
  series = {ICPP '23}
  }
  ```

  Colossal-AI has been accepted as official tutorial by top conferences [NeurIPS](https://nips.cc/), [SC](https://sc22.supercomputing.org/), [AAAI](https://aaai.org/Conferences/AAAI-23/),
  [PPoPP](https://ppopp23.sigplan.org/), [CVPR](https://cvpr2023.thecvf.com/), [ISC](https://www.isc-hpc.com/), [NVIDIA GTC](https://www.nvidia.com/en-us/on-demand/session/gtcspring23-S51482/) ,etc.

  <p align="right">(<a href="#top">back to top</a>)</p>


pkgId: b5283f5d105b86df5e22db2a6645f12a838083225f5e86eb3e89619dc28630f5
name: python-colossalai-nightly
arch: src
version: 2024.11.23
epoch: 0
release: 1
summary: An integrated large-scale model training system with efficient parallelization techniques
url: https://www.colossalai.org
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colossalai-nightly-2024.11.23-1.src.rpm
checksum_type: sha256
description:
  <div id="top" align="center">

     [![logo](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/colossal-ai_logo_vertical.png)](https://www.colossalai.org/)

     Colossal-AI: Making large AI models cheaper, faster, and more accessible

     <h3> <a href="https://arxiv.org/abs/2110.14883"> Paper </a> |
     <a href="https://www.colossalai.org/"> Documentation </a> |
     <a href="https://github.com/hpcaitech/ColossalAI/tree/main/examples"> Examples </a> |
     <a href="https://github.com/hpcaitech/ColossalAI/discussions"> Forum </a> |
     <a href="https://cloud.luchentech.com/">GPU Cloud Playground </a> |
     <a href="https://hpc-ai.com/blog"> Blog </a></h3>

     [![GitHub Repo stars](https://img.shields.io/github/stars/hpcaitech/ColossalAI?style=social)](https://github.com/hpcaitech/ColossalAI/stargazers)
     [![Build](https://github.com/hpcaitech/ColossalAI/actions/workflows/build_on_schedule.yml/badge.svg)](https://github.com/hpcaitech/ColossalAI/actions/workflows/build_on_schedule.yml)
     [![Documentation](https://readthedocs.org/projects/colossalai/badge/?version=latest)](https://colossalai.readthedocs.io/en/latest/?badge=latest)
     [![CodeFactor](https://www.codefactor.io/repository/github/hpcaitech/colossalai/badge)](https://www.codefactor.io/repository/github/hpcaitech/colossalai)
     [![HuggingFace badge](https://img.shields.io/badge/%F0%9F%A4%97HuggingFace-Join-yellow)](https://huggingface.co/hpcai-tech)
     [![slack badge](https://img.shields.io/badge/Slack-join-blueviolet?logo=slack&amp)](https://github.com/hpcaitech/public_assets/tree/main/colossalai/contact/slack)
     [![WeChat badge](https://img.shields.io/badge/微信-加入-green?logo=wechat&amp)](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/WeChat.png)


     | [English](README.md) | [中文](docs/README-zh-Hans.md) |

  </div>



  Access high-end, on-demand compute for your research instantly—no setup needed.

  Sign up now and get $10 in credits!

  Limited Academic Bonuses:

  * Top up $1,000 and receive 300 credits
  * Top up $500 and receive 100 credits

  <div align="center">
     <a href="https://hpc-ai.com/?utm_source=github&utm_medium=social&utm_campaign=promotion-colossalai">
     <img src="https://github.com/hpcaitech/public_assets/blob/main/colossalai/img/2.gif" width="850" />
     </a>
  </div>



  * [2024/10] [How to build a low-cost Sora-like app? Solutions for you](https://company.hpc-ai.com/blog/how-to-build-a-low-cost-sora-like-app-solutions-for-you)
  * [2024/09] [Singapore Startup HPC-AI Tech Secures 50 Million USD in Series A Funding to Build the Video Generation AI Model and GPU Platform](https://company.hpc-ai.com/blog/singapore-startup-hpc-ai-tech-secures-50-million-usd-in-series-a-funding-to-build-the-video-generation-ai-model-and-gpu-platform)
  * [2024/09] [Reducing AI Large Model Training Costs by 30% Requires Just a Single Line of Code From FP8 Mixed Precision Training Upgrades](https://company.hpc-ai.com/blog/reducing-ai-large-model-training-costs-by-30-requires-just-a-single-line-of-code-from-fp8-mixed-precision-training-upgrades)
  * [2024/06] [Open-Sora Continues Open Source: Generate Any 16-Second 720p HD Video with One Click, Model Weights Ready to Use](https://hpc-ai.com/blog/open-sora-from-hpc-ai-tech-team-continues-open-source-generate-any-16-second-720p-hd-video-with-one-click-model-weights-ready-to-use)
  * [2024/05] [Large AI Models Inference Speed Doubled, Colossal-Inference Open Source Release](https://hpc-ai.com/blog/colossal-inference)
  * [2024/04] [Open-Sora Unveils Major Upgrade: Embracing Open Source with Single-Shot 16-Second Video Generation and 720p Resolution](https://hpc-ai.com/blog/open-soras-comprehensive-upgrade-unveiled-embracing-16-second-video-generation-and-720p-resolution-in-open-source)
  * [2024/04] [Most cost-effective solutions for inference, fine-tuning and pretraining, tailored to LLaMA3 series](https://hpc-ai.com/blog/most-cost-effective-solutions-for-inference-fine-tuning-and-pretraining-tailored-to-llama3-series)


  <ul>
   <li><a href="#Why-Colossal-AI">Why Colossal-AI</a> </li>
   <li><a href="#Features">Features</a> </li>
   <li>
     <a href="#Colossal-AI-in-the-Real-World">Colossal-AI for Real World Applications</a>
     <ul>
       <li><a href="#Open-Sora">Open-Sora: Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models</a></li>
       <li><a href="#Colossal-LLaMA-2">Colossal-LLaMA-2: One Half-Day of Training Using a Few Hundred Dollars Yields Similar Results to Mainstream Large Models, Open-Source and Commercial-Free Domain-Specific Llm Solution</a></li>
       <li><a href="#ColossalChat">ColossalChat: An Open-Source Solution for Cloning ChatGPT With a Complete RLHF Pipeline</a></li>
       <li><a href="#AIGC">AIGC: Acceleration of Stable Diffusion</a></li>
       <li><a href="#Biomedicine">Biomedicine: Acceleration of AlphaFold Protein Structure</a></li>
     </ul>
   </li>
   <li>
     <a href="#Parallel-Training-Demo">Parallel Training Demo</a>
     <ul>
       <li><a href="#LLaMA3">LLaMA 1/2/3 </a></li>
       <li><a href="#MoE">MoE</a></li>
       <li><a href="#GPT-3">GPT-3</a></li>
       <li><a href="#GPT-2">GPT-2</a></li>
       <li><a href="#BERT">BERT</a></li>
       <li><a href="#PaLM">PaLM</a></li>
       <li><a href="#OPT">OPT</a></li>
       <li><a href="#ViT">ViT</a></li>
       <li><a href="#Recommendation-System-Models">Recommendation System Models</a></li>
     </ul>
   </li>
   <li>
     <a href="#Single-GPU-Training-Demo">Single GPU Training Demo</a>
     <ul>
       <li><a href="#GPT-2-Single">GPT-2</a></li>
       <li><a href="#PaLM-Single">PaLM</a></li>
     </ul>
   </li>
   <li>
     <a href="#Inference">Inference</a>
     <ul>
       <li><a href="#Colossal-Inference">Colossal-Inference: Large AI  Models Inference Speed Doubled</a></li>
       <li><a href="#Grok-1">Grok-1: 314B model of PyTorch + HuggingFace Inference</a></li>
       <li><a href="#SwiftInfer">SwiftInfer:Breaks the Length Limit of LLM for Multi-Round Conversations with 46% Acceleration</a></li>
     </ul>
   </li>
   <li>
     <a href="#Installation">Installation</a>
     <ul>
       <li><a href="#PyPI">PyPI</a></li>
       <li><a href="#Install-From-Source">Install From Source</a></li>
     </ul>
   </li>
   <li><a href="#Use-Docker">Use Docker</a></li>
   <li><a href="#Community">Community</a></li>
   <li><a href="#Contributing">Contributing</a></li>
   <li><a href="#Cite-Us">Cite Us</a></li>
  </ul>


  <div align="center">
     <a href="https://youtu.be/KnXSfjqkKN0">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/JamesDemmel_Colossal-AI.png" width="600" />
     </a>

     Prof. James Demmel (UC Berkeley): Colossal-AI makes training AI models efficient, easy, and scalable.
  </div>

  <p align="right">(<a href="#top">back to top</a>)</p>



  Colossal-AI provides a collection of parallel components for you. We aim to support you to write your
  distributed deep learning models just like how you write your model on your laptop. We provide user-friendly tools to kickstart
  distributed training and inference in a few lines.

  - Parallelism strategies
    - Data Parallelism
    - Pipeline Parallelism
    - 1D, [2D](https://arxiv.org/abs/2104.05343), [2.5D](https://arxiv.org/abs/2105.14500), [3D](https://arxiv.org/abs/2105.14450) Tensor Parallelism
    - [Sequence Parallelism](https://arxiv.org/abs/2105.13120)
    - [Zero Redundancy Optimizer (ZeRO)](https://arxiv.org/abs/1910.02054)
    - [Auto-Parallelism](https://arxiv.org/abs/2302.02599)

  - Heterogeneous Memory Management
    - [PatrickStar](https://arxiv.org/abs/2108.05818)

  - Friendly Usage
    - Parallelism based on the configuration file

  <p align="right">(<a href="#top">back to top</a>)</p>




  [Open-Sora](https://github.com/hpcaitech/Open-Sora)：Revealing Complete Model Parameters, Training Details, and Everything for Sora-like Video Generation Models
  [[code]](https://github.com/hpcaitech/Open-Sora)
  [[blog]](https://hpc-ai.com/blog/open-sora-from-hpc-ai-tech-team-continues-open-source-generate-any-16-second-720p-hd-video-with-one-click-model-weights-ready-to-use)
  [[Model weights]](https://github.com/hpcaitech/Open-Sora?tab=readme-ov-file#model-weights)
  [[Demo]](https://github.com/hpcaitech/Open-Sora?tab=readme-ov-file#-latest-demo)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[OpenSora Image]](https://cloud.luchentech.com/doc/docs/image/open-sora/)

  <div align="center">
     <a href="https://youtu.be/ilMQpU71ddI?si=J4JSPzZ03ycYmlki">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/sora/opensora-v1.2.png" width="700" />
     </a>
  </div>

  <p align="right">(<a href="#top">back to top</a>)</p>



  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)

  - 7B: One half-day of training using a few hundred dollars yields similar results to mainstream large models, open-source and commercial-free domain-specific LLM solution.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Colossal-LLaMA-2)
  [[blog]](https://www.hpc-ai.tech/blog/one-half-day-of-training-using-a-few-hundred-dollars-yields-similar-results-to-mainstream-large-models-open-source-and-commercial-free-domain-specific-llm-solution)
  [[HuggingFace model weights]](https://huggingface.co/hpcai-tech/Colossal-LLaMA-2-7b-base)
  [[Modelscope model weights]](https://www.modelscope.cn/models/colossalai/Colossal-LLaMA-2-7b-base/summary)

  - 13B: Construct refined 13B private model with just $5000 USD.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Colossal-LLaMA-2)
  [[blog]](https://hpc-ai.com/blog/colossal-llama-2-13b)
  [[HuggingFace model weights]](https://huggingface.co/hpcai-tech/Colossal-LLaMA-2-13b-base)
  [[Modelscope model weights]](https://www.modelscope.cn/models/colossalai/Colossal-LLaMA-2-13b-base/summary)

  |              Model              |  Backbone  | Tokens Consumed |     MMLU (5-shot)    | CMMLU (5-shot)| AGIEval (5-shot) | GAOKAO (0-shot) | CEval (5-shot)  |
  | :-----------------------------: | :--------: | :-------------: | :------------------: | :-----------: | :--------------: | :-------------: | :-------------: |
  |          Baichuan-7B            |     -      |      1.2T       |    42.32 (42.30)     | 44.53 (44.02) |        38.72     |       36.74     |       42.80     |
  |       Baichuan-13B-Base         |     -      |      1.4T       |    50.51 (51.60)     | 55.73 (55.30) |        47.20     |       51.41     |       53.60     |
  |       Baichuan2-7B-Base         |     -      |      2.6T       |    46.97 (54.16)     | 57.67 (57.07) |        45.76     |       52.60     |       54.00     |
  |       Baichuan2-13B-Base        |     -      |      2.6T       |    54.84 (59.17)     | 62.62 (61.97) |        52.08     |       58.25     |       58.10     |
  |           ChatGLM-6B            |     -      |      1.0T       |    39.67 (40.63)     |   41.17 (-)   |        40.10     |       36.53     |       38.90     |
  |          ChatGLM2-6B            |     -      |      1.4T       |    44.74 (45.46)     |   49.40 (-)   |        46.36     |       45.49     |       51.70     |
  |          InternLM-7B            |     -      |      1.6T       |    46.70 (51.00)     |   52.00 (-)   |        44.77     |       61.64     |       52.80     |
  |            Qwen-7B              |     -      |      2.2T       |    54.29 (56.70)     | 56.03 (58.80) |        52.47     |       56.42     |       59.60     |
  |           Llama-2-7B            |     -      |      2.0T       |    44.47 (45.30)     |   32.97 (-)   |        32.60     |       25.46     |         -       |
  | Linly-AI/Chinese-LLaMA-2-7B-hf  | Llama-2-7B |      1.0T       |        37.43         |     29.92     |        32.00     |       27.57     |         -       |
  | wenge-research/yayi-7b-llama2   | Llama-2-7B |        -        |        38.56         |     31.52     |        30.99     |       25.95     |         -       |
  | ziqingyang/chinese-llama-2-7b   | Llama-2-7B |        -        |        33.86         |     34.69     |        34.52     |       25.18     |        34.2     |
  | TigerResearch/tigerbot-7b-base  | Llama-2-7B |      0.3T       |        43.73         |     42.04     |        37.64     |       30.61     |         -       |
  |  LinkSoul/Chinese-Llama-2-7b    | Llama-2-7B |        -        |        48.41         |     38.31     |        38.45     |       27.72     |         -       |
  |       FlagAlpha/Atom-7B         | Llama-2-7B |      0.1T       |        49.96         |     41.10     |        39.83     |       33.00     |         -       |
  | IDEA-CCNL/Ziya-LLaMA-13B-v1.1   | Llama-13B  |      0.11T      |        50.25         |     40.99     |        40.04     |       30.54     |         -       |
  |  **Colossal-LLaMA-2-7b-base**   | Llama-2-7B |   **0.0085T**   |        53.06         |     49.89     |        51.48     |       58.82     |        50.2     |
  |  **Colossal-LLaMA-2-13b-base**  | Llama-2-13B |   **0.025T**    |        56.42         |     61.80     |        54.69     |       69.53     |        60.3     |




  <div align="center">
     <a href="https://www.youtube.com/watch?v=HcTiHzApHm0">
     <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chat/ColossalChat%20YouTube.png" width="700" />
     </a>
  </div>

  [ColossalChat](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Chat): An open-source solution for cloning [ChatGPT](https://openai.com/blog/chatgpt/) with a complete RLHF pipeline.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/applications/Chat)
  [[blog]](https://medium.com/@yangyou_berkeley/colossalchat-an-open-source-solution-for-cloning-chatgpt-with-a-complete-rlhf-pipeline-5edf08fb538b)
  [[demo]](https://www.youtube.com/watch?v=HcTiHzApHm0)
  [[tutorial]](https://www.youtube.com/watch?v=-qFBZFmOJfg)

  <p id="ColossalChat-Speed" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chat/ColossalChat%20Speed.jpg" width=450/>
  </p>

  - Up to 10 times faster for RLHF PPO Stage3 Training

  <p id="ColossalChat_scaling" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/ChatGPT%20scaling.png" width=800/>
  </p>

  - Up to 7.73 times faster for single server training and 1.42 times faster for single-GPU inference

  <p id="ColossalChat-1GPU" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/ChatGPT-1GPU.jpg" width=450/>
  </p>

  - Up to 10.3x growth in model capacity on one GPU
  - A mini demo training process requires only 1.62GB of GPU memory (any consumer-grade GPU)

  <p id="ColossalChat-LoRA" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/applications/chatgpt/LoRA%20data.jpg" width=600/>
  </p>

  - Increase the capacity of the fine-tuning model by up to 3.7 times on a single GPU
  - Keep at a sufficiently high running speed

  <p align="right">(<a href="#top">back to top</a>)</p>



  Acceleration of AIGC (AI-Generated Content) models such as [Stable Diffusion v1](https://github.com/CompVis/stable-diffusion) and [Stable Diffusion v2](https://github.com/Stability-AI/stablediffusion).
  <p id="diffusion_train" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/Stable%20Diffusion%20v2.png" width=800/>
  </p>

  - [Training](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/diffusion): Reduce Stable Diffusion memory consumption by up to 5.6x and hardware cost by up to 46x (from A100 to RTX3060).

  <p id="diffusion_demo" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/DreamBooth.png" width=800/>
  </p>

  - [DreamBooth Fine-tuning](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/dreambooth): Personalize your model using just 3-5 images of the desired subject.

  <p id="inference-sd" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/Stable%20Diffusion%20Inference.jpg" width=800/>
  </p>

  - [Inference](https://github.com/hpcaitech/ColossalAI/tree/main/examples/images/diffusion): Reduce inference GPU memory consumption by 2.5x.


  <p align="right">(<a href="#top">back to top</a>)</p>


  Acceleration of [AlphaFold Protein Structure](https://alphafold.ebi.ac.uk/)

  <p id="FastFold" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/FastFold.jpg" width=800/>
  </p>

  - [FastFold](https://github.com/hpcaitech/FastFold): Accelerating training and inference on GPU Clusters, faster data processing, inference sequence containing more than 10000 residues.

  <p id="FastFold-Intel" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/data%20preprocessing%20with%20Intel.jpg" width=600/>
  </p>

  - [FastFold with Intel](https://github.com/hpcaitech/FastFold): 3x inference acceleration and 39% cost reduce.

  <p id="xTrimoMultimer" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/xTrimoMultimer_Table.jpg" width=800/>
  </p>

  - [xTrimoMultimer](https://github.com/biomap-research/xTrimoMultimer): accelerating structure prediction of protein monomers and multimer by 11x.


  <p align="right">(<a href="#top">back to top</a>)</p>



  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/LLaMA3-70B-H100.png" width=600/>
  </p>

  - 70 billion parameter LLaMA3 model training accelerated by 18%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/llama2_pretraining.png" width=600/>
  </p>

  - 70 billion parameter LLaMA2 model training accelerated by 195%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[blog]](https://www.hpc-ai.tech/blog/70b-llama2-training)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/LLaMA_pretraining.png" width=600/>
  </p>

  - 65-billion-parameter large model pretraining accelerated by 38%
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/llama)
  [[blog]](https://www.hpc-ai.tech/blog/large-model-pretraining)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/MOE_training.png" width=800/>
  </p>

  - Enhanced MoE parallelism, Open-source MoE model training can be 9 times more efficient
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/openmoe)
  [[blog]](https://www.hpc-ai.tech/blog/enhanced-moe-parallelism-open-source-moe-model-training-can-be-9-times-more-efficient)


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT3-v5.png" width=700/>
  </p>

  - Save 50% GPU resources and 10.7% acceleration


  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2.png" width=800/>

  - 11x lower GPU memory consumption, and superlinear scaling efficiency with Tensor Parallelism

  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/(updated)GPT-2.png" width=800>

  - 24x larger model size on the same hardware
  - over 3x acceleration

  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/BERT.png" width=800/>

  - 2x faster training, or 50% longer sequence length


  - [PaLM-colossalai](https://github.com/hpcaitech/PaLM-colossalai): Scalable implementation of Google's Pathways Language Model ([PaLM](https://ai.googleblog.com/2022/04/pathways-language-model-palm-scaling-to.html)).


  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/OPT_update.png" width=800/>

  - [Open Pretrained Transformer (OPT)](https://github.com/facebookresearch/metaseq), a 175-Billion parameter AI language model released by Meta, which stimulates AI programmers to perform various downstream tasks and application deployments because of public pre-trained model weights.
  - 45% speedup fine-tuning OPT at low cost in lines. [[Example]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/opt) [[Online Serving]](https://colossalai.org/docs/advanced_tutorials/opt_service)

  Please visit our [documentation](https://www.colossalai.org/) and [examples](https://github.com/hpcaitech/ColossalAI/tree/main/examples) for more details.


  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/ViT.png" width="450" />
  </p>

  - 14x larger batch size, and 5x faster training for Tensor Parallelism = 64


  - [Cached Embedding](https://github.com/hpcaitech/CachedEmbedding), utilize software cache to train larger embedding tables with a smaller GPU memory budget.

  <p align="right">(<a href="#top">back to top</a>)</p>




  <p id="GPT-2-Single" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2-GPU1.png" width=450/>
  </p>

  - 20x larger model size on the same hardware

  <p id="GPT-2-NVME" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/GPT2-NVME.png" width=800/>
  </p>

  - 120x larger model size on the same hardware (RTX 3080)


  <p id="PaLM-Single" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/PaLM-GPU1.png" width=450/>
  </p>

  - 34x larger model size on the same hardware

  <p align="right">(<a href="#top">back to top</a>)</p>




  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/inference/colossal-inference-v1-1.png" width=1000/>
  </p>

  <p align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/inference/colossal-inference-v1-2.png" width=1000/>
  </p>

   - Large AI models inference speed doubled, compared to the offline inference performance of vLLM in some cases.
  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/colossalai/inference)
  [[blog]](https://hpc-ai.com/blog/colossal-inference)
  [[GPU Cloud Playground]](https://cloud.luchentech.com/)
  [[LLaMA3 Image]](https://cloud.luchentech.com/doc/docs/image/llama)


  <p id="Grok-1" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/examples/images/grok-1-inference.jpg" width=600/>
  </p>

   - 314 Billion Parameter Grok-1 Inference Accelerated by 3.8x, an easy-to-use Python + PyTorch + HuggingFace version for Inference.

  [[code]](https://github.com/hpcaitech/ColossalAI/tree/main/examples/language/grok-1)
  [[blog]](https://hpc-ai.com/blog/314-billion-parameter-grok-1-inference-accelerated-by-3.8x-efficient-and-easy-to-use-pytorchhuggingface-version-is-here)
  [[HuggingFace Grok-1 PyTorch model weights]](https://huggingface.co/hpcai-tech/grok-1)
  [[ModelScope Grok-1 PyTorch model weights]](https://www.modelscope.cn/models/colossalai/grok-1-pytorch/summary)


  <p id="SwiftInfer" align="center">
  <img src="https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/SwiftInfer.jpg" width=800/>
  </p>

  - [SwiftInfer](https://github.com/hpcaitech/SwiftInfer): Inference performance improved by 46%, open source solution breaks the length limit of LLM for multi-round conversations

  <p align="right">(<a href="#top">back to top</a>)</p>



  Requirements:
  - PyTorch >= 2.2
  - Python >= 3.7
  - CUDA >= 11.0
  - [NVIDIA GPU Compute Capability](https://developer.nvidia.com/cuda-gpus) >= 7.0 (V100/RTX20 and higher)
  - Linux OS

  If you encounter any problem with installation, you may want to raise an [issue](https://github.com/hpcaitech/ColossalAI/issues/new/choose) in this repository.



  You can easily install Colossal-AI with the following command. **By default, we do not build PyTorch extensions during installation.**

  ```bash
  pip install colossalai
  ```

  **Note: only Linux is supported for now.**

  However, if you want to build the PyTorch extensions during installation, you can set `BUILD_EXT=1`.

  ```bash
  BUILD_EXT=1 pip install colossalai
  ```

  **Otherwise, CUDA kernels will be built during runtime when you actually need them.**

  We also keep releasing the nightly version to PyPI every week. This allows you to access the unreleased features and bug fixes in the main branch.
  Installation can be made via

  ```bash
  pip install colossalai-nightly
  ```



  > The version of Colossal-AI will be in line with the main branch of the repository. Feel free to raise an issue if you encounter any problems. :)

  ```shell
  git clone https://github.com/hpcaitech/ColossalAI.git
  cd ColossalAI


  pip install .
  ```

  By default, we do not compile CUDA/C++ kernels. ColossalAI will build them during runtime.
  If you want to install and enable CUDA kernel fusion (compulsory installation when using fused optimizer):

  ```shell
  BUILD_EXT=1 pip install .
  ```

  For Users with CUDA 10.2, you can still build ColossalAI from source. However, you need to manually download the cub library and copy it to the corresponding directory.

  ```bash

  git clone https://github.com/hpcaitech/ColossalAI.git
  cd ColossalAI


  wget https://github.com/NVIDIA/cub/archive/refs/tags/1.8.0.zip
  unzip 1.8.0.zip
  cp -r cub-1.8.0/cub/ colossalai/kernel/cuda_native/csrc/kernels/include/


  BUILD_EXT=1 pip install .
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>





  You can directly pull the docker image from our [DockerHub page](https://hub.docker.com/r/hpcaitech/colossalai). The image is automatically uploaded upon release.




  Run the following command to build a docker image from Dockerfile provided.

  > Building Colossal-AI from scratch requires GPU support, you need to use Nvidia Docker Runtime as the default when doing `docker build`. More details can be found [here](https://stackoverflow.com/questions/59691207/docker-build-with-nvidia-runtime).
  > We recommend you install Colossal-AI from our [project page](https://www.colossalai.org) directly.


  ```bash
  cd ColossalAI
  docker build -t colossalai ./docker
  ```

  Run the following command to start the docker container in interactive mode.

  ```bash
  docker run -ti --gpus all --rm --ipc=host colossalai bash
  ```

  <p align="right">(<a href="#top">back to top</a>)</p>



  Join the Colossal-AI community on [Forum](https://github.com/hpcaitech/ColossalAI/discussions),
  [Slack](https://join.slack.com/t/colossalaiworkspace/shared_invite/zt-z7b26eeb-CBp7jouvu~r0~lcFzX832w),
  and [WeChat(微信)](https://raw.githubusercontent.com/hpcaitech/public_assets/main/colossalai/img/WeChat.png "qrcode") to share your suggestions, feedback, and questions with our engineering team.


  Referring to the successful attempts of [BLOOM](https://bigscience.huggingface.co/) and [Stable Diffusion](https://en.wikipedia.org/wiki/Stable_Diffusion), any and all developers and partners with computing powers, datasets, models are welcome to join and build the Colossal-AI community, making efforts towards the era of big AI models!

  You may contact us or participate in the following ways:
  1. [Leaving a Star ⭐](https://github.com/hpcaitech/ColossalAI/stargazers) to show your like and support. Thanks!
  2. Posting an [issue](https://github.com/hpcaitech/ColossalAI/issues/new/choose), or submitting a PR on GitHub follow the guideline in [Contributing](https://github.com/hpcaitech/ColossalAI/blob/main/CONTRIBUTING.md)
  3. Send your official proposal to email contact@hpcaitech.com

  Thanks so much to all of our amazing contributors!

  <a href="https://github.com/hpcaitech/ColossalAI/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=hpcaitech/ColossalAI"  width="800px"/>
  </a>


  <p align="right">(<a href="#top">back to top</a>)</p>




  We leverage the power of [GitHub Actions](https://github.com/features/actions) to automate our development, release and deployment workflows. Please check out this [documentation](.github/workflows/README.md) on how the automated workflows are operated.




  This project is inspired by some related projects (some by our team and some by other organizations). We would like to credit these amazing projects as listed in the [Reference List](./docs/REFERENCE.md).

  To cite this project, you can use the following BibTeX citation.

  ```
  @inproceedings{10.1145/3605573.3605613,
  author = {Li, Shenggui and Liu, Hongxin and Bian, Zhengda and Fang, Jiarui and Huang, Haichen and Liu, Yuliang and Wang, Boxiang and You, Yang},
  title = {Colossal-AI: A Unified Deep Learning System For Large-Scale Parallel Training},
  year = {2023},
  isbn = {9798400708435},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3605573.3605613},
  doi = {10.1145/3605573.3605613},
  abstract = {The success of Transformer models has pushed the deep learning model scale to billions of parameters, but the memory limitation of a single GPU has led to an urgent need for training on multi-GPU clusters. However, the best practice for choosing the optimal parallel strategy is still lacking, as it requires domain expertise in both deep learning and parallel computing. The Colossal-AI system addressed the above challenge by introducing a unified interface to scale your sequential code of model training to distributed environments. It supports parallel training methods such as data, pipeline, tensor, and sequence parallelism and is integrated with heterogeneous training and zero redundancy optimizer. Compared to the baseline system, Colossal-AI can achieve up to 2.76 times training speedup on large-scale models.},
  booktitle = {Proceedings of the 52nd International Conference on Parallel Processing},
  pages = {766–775},
  numpages = {10},
  keywords = {datasets, gaze detection, text tagging, neural networks},
  location = {Salt Lake City, UT, USA},
  series = {ICPP '23}
  }
  ```

  Colossal-AI has been accepted as official tutorial by top conferences [NeurIPS](https://nips.cc/), [SC](https://sc22.supercomputing.org/), [AAAI](https://aaai.org/Conferences/AAAI-23/),
  [PPoPP](https://ppopp23.sigplan.org/), [CVPR](https://cvpr2023.thecvf.com/), [ISC](https://www.isc-hpc.com/), [NVIDIA GTC](https://www.nvidia.com/en-us/on-demand/session/gtcspring23-S51482/) ,etc.

  <p align="right">(<a href="#top">back to top</a>)</p>


pkgId: c8538877eaec2764e23ed2a63ce1aa99c2c559bac611925336682bf2c219902d
name: python-colosseum
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: An independent implementation of the CSS layout algorithm.
url: https://github.com/pybee/colosseum
rpm_license: New BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colosseum-0.2.0-1.src.rpm
checksum_type: sha256
description:
  An independent implementation of the CSS layout algorithm. This
  implementation is completely standalone - it isn't dependent on
  a browser, and can be run over any box-like set of objects that
  need to be laid out on a page (either physical or virtual)


pkgId: 2ba9ee76779655c7b02e040fdded10f9ece9db7e8b5fbccaa10aebaaf4ff4490
name: python-colossus
arch: src
version: 1.3.6
epoch: 0
release: 1
summary: Cosmology, halo, and large-scale structure tools
url: https://bitbucket.org/bdiemer/colossus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colossus-1.3.6-1.src.rpm
checksum_type: sha256
description:
  Colossus is an astrophysics toolkit, the name is an acronym for **CO**\ smology,
  ha\ **LO**\ , and large-**S**\ cale **S**\ tr\ **U**\ cture tool\ **S**\ . Please consult
  the `Online Documentation <https://bdiemer.bitbucket.io/colossus/>`__ for details.


pkgId: 0c922c85cf148fc0c74df0a7a4a05d2658532300d2a29ac212b4f178dcda254d
name: python-colour-checker-detection
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Colour checker detection with Python
url: https://www.colour-science.org
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colour-checker-detection-0.2.1-1.src.rpm
checksum_type: sha256
description:
  |actions| |coveralls| |codacy| |version|
  A `Python <https://www.python.org>`__ package implementing various colour
  checker detection algorithms and related utilities.
  It is open source and freely available under the
  `BSD-3-Clause <https://opensource.org/licenses/BSD-3-Clause>`__ terms.


pkgId: ca09d246574c02a61b3b837fc04968002c570806a3ab962df8dafd57ce5428bd
name: python-colour-demosaicing
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: CFA (Colour Filter Array) Demosaicing Algorithms for Python
url: https://www.colour-science.org
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colour-demosaicing-0.2.6-1.src.rpm
checksum_type: sha256
description:
  |actions| |coveralls| |codacy| |version|
  A `Python <https://www.python.org>`__ package implementing various
  CFA (Colour Filter Array) demosaicing algorithms and related utilities.
  It is open source and freely available under the
  `BSD-3-Clause <https://opensource.org/licenses/BSD-3-Clause>`__ terms.


pkgId: d7d40ee0b7601869e82f4045c8d91c02086b38f2e45b6c5e95b1761b0e15ed61
name: python-colour-fx
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/Max-Derner/colour_fx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colour-fx-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  Colour handling through 4 bit and 8 bit ANSI escape sequences. Powerful effects like gradients for blocks of text such as figlet banners.

description:
  [![Testing and linting](https://github.com/Max-Derner/colour_effects/actions/workflows/python-testing.yml/badge.svg?branch=main)](https://github.com/Max-Derner/colour_effects/actions/workflows/python-testing.yml)


  ![promo image](https://github.com/Max-Derner/colour_fx/blob/main/README_IMGS/promo_img.png?raw=true)

  This a project to develop a Python PyPI package that not just handles colour text output but can also apply colour effects such as gradients to your text.




  This package uses ANSI escape sequence select graphics renditions in order to apply colour and style to text and backgrounds.
  How is this package any different to the others?
  * 8 bit codes as well as 4 bit codes
  * there is an ever expanding library of effects that can be applied to larger blocks of texts.
  * super slick and simple interface



  Different terminals render colours differently, some terminals don't even render ANSI escape sequences at all, leading to a big mess of text. Playing around with ANSI escape codes is just that, it is playing.

  Some basic colours used sparingly to highlight different logging levels is fine but you can't get carried away with colours in serious projects.



  First, there 4 bit and 8 bit codes available, import from `colour_fx.four_bit` and `colour_fx.eight_bit` respectively. However, both 8 bit and 4 bit codes can be used together without issue.


  The objects in these modules only provide the the value to be used inside an ANSI escape sequence. They will need to be compiled into an ANSI escape sequence using `compile_ansi_code` which can be imported with `from colour_fx import compile_ansi_code`.


  ```python
  from colour_fx import compile_ansi_code
  from colour_fx.four_bit import Colour, Style

  blinking_red_on_yellow = compile_ansi_code(
      
      
      Colour.RED,
      Colour.YELLOW.bright_background,
      Style.BLINK
  )



  RESET = compile_ansi_code()

  print(F"HELLO, {blinking_red_on_yellow}WORLD{RESET}!")
  ```
  ![Colour example output](https://github.com/Max-Derner/colour_fx/blob/main/README_IMGS/Colour-example-output.gif?raw=true)




  8 bit colours are much more unpredictable in appearance between different terminals than 4 bit colours are.


  ```python
  from colour_fx import compile_ansi_code
  from colour_fx.eight_bit import SimpleColour

  red_on_yellow = compile_ansi_code(
      
      
      SimpleColour.RED,
      SimpleColour.YELLOW.bright_background,
  )



  RESET = compile_ansi_code()

  print(F"HELLO, {red_on_yellow}WORLD{RESET}!")
  ```

  ![SipleColour example output](https://github.com/Max-Derner/colour_fx/blob/main//README_IMGS/SimpleColour-example-output.png?raw=true)


  ```python
  from colour_fx import compile_ansi_code
  from colour_fx.eight_bit import Grey



  grey_array = [
      Grey.AA,
      Grey.AC,
      Grey.AE,
      Grey.BB,
      Grey.BD,
      Grey.BF,
      Grey.CA,
      Grey.CC,
      Grey.CE,
      Grey.DB,
      Grey.DD,
      Grey.DF,
  ]



  grey_back = [grey.background for grey in reversed(grey_array)]


  g = [
      compile_ansi_code(
          grey_array[idx],
          grey_back[idx],
      )
      for idx in range(len(grey_array))
  ]



  RESET = compile_ansi_code()



  print(
      F"{g[0]}H{g[1]}E{g[2]}L{g[3]}L{g[4]}O{g[5]},"
      F"{g[6]} W{g[7]}O{g[8]}R{g[9]}L{g[10]}D{g[11]}!{RESET}"
  )
  ```

  ![Grey example output](https://github.com/Max-Derner/colour_fx/blob/main/README_IMGS/Grey-example-output.png?raw=true)


  ```python
  from colour_fx import compile_ansi_code
  from colour_fx.eight_bit import RGB





  spectrum = [
      RGB(5, 0, 0).foreground,
      RGB(3, 2, 0).foreground,
      RGB(1, 4, 0).foreground,
      RGB(0, 4, 1).foreground,
      RGB(0, 2, 3).foreground,
      RGB(0, 0, 5).foreground,
  ]



  s = [
      compile_ansi_code(spec, RGB(5, 5, 5).background)
      for spec in spectrum
  ]



  RESET = compile_ansi_code()


  print(F"{s[0]}HE{s[1]}LL{s[2]}O,{s[3]} WO{s[4]}RL{s[5]}D!{RESET}")
  ```


  ![RGB output](https://github.com/Max-Derner/colour_fx/blob/main/README_IMGS/RGB-example-output.png?raw=true)



  Now this is what inspired the creation of this package, being able to apply gradients to large blocks of text.


  ```python
  from colour_fx.four_bit import Colour
  from colour_fx.effects.gradients import create_vertical_gradient_field
  from colour_fx.effects import apply_ansi_field

  rainbow_vals = [
      [Colour.RED],
      [Colour.RED.bright],
      [Colour.YELLOW.bright],
      [Colour.GREEN],
      [Colour.BLUE],
      [Colour.BLUE.bright],
      [Colour.MAGENTA],
  ]

  text_to_render = (
      "       :::    ::: :::::::::: :::        :::        ::::::::  ::: \n"
      "      :+:    :+: :+:        :+:        :+:       :+:    :+: :+:  \n"
      "     +:+    +:+ +:+        +:+        +:+       +:+    +:+ +:+   \n"
      "    +#++:++#++ +#++:++#   +#+        +#+       +#+    +:+ +#+    \n"
      "   +#+    +#+ +#+        +#+        +#+       +#+    +#+ +#+     \n"
      "  #+#    #+# #+#        #+#        #+#       #+#    #+#          \n"
      " ###    ### ########## ########## ########## ########  ###       \n"
  )

  output_field = create_vertical_gradient_field(
      template=text_to_render,
      ansi_vals=rainbow_vals,
      indent=3,
      step=1,
  )

  output_text = apply_ansi_field(
      text=text_to_render,
      field=output_field
  )

  print(output_text)
  ```

  ![vertical gradient example output](https://github.com/Max-Derner/colour_fx/blob/main/README_IMGS/vertical-gradient-example-output.png?raw=true)



  Don't use Windows, install Python 3.9, then use `source ./tooling && venv-setup` to get yourself a venv set up with Python 3.9 (our lowest supported Python version)

  Use command `lint-cfx` to lint work, and command `test-cfx` to test work.

  Use a branch in your name to do feature work, then submit a pull request.


pkgId: ca05fd98f6ed15c3feba481971f5c303390cf2469d9b3405d2d128499893f805
name: python-colour-science
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: Colour Science for Python
url: https://www.colour-science.org
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colour-science-0.4.6-1.src.rpm
checksum_type: sha256
description:
  The draft release notes of the
  `develop <https://github.com/colour-science/colour/tree/develop>`__
  branch are available at this
  `url <https://gist.github.com/KelSolaar/4a6ebe9ec3d389f0934b154fec8df51d>`__.


pkgId: 37c5ffa98e9cfd4135a69d52c2f5c1c1b23a9cbb506dc1535bb4d3601a77f8e5
name: python-colouration
arch: src
version: 2020.7.26
epoch: 0
release: 1
summary: Python library for working with colours
url: https://github.com/idin/colouration
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colouration-2020.7.26-1.src.rpm
checksum_type: sha256
description:
  *Colouration* is a Python library for working with colours.
  It unifies three representation of colour:
  - [RGB](https://en.wikipedia.org/wiki/RGB_color_model) (red, green, blue)
  - [HSL](https://en.wikipedia.org/wiki/HSL_and_HSV) (hue, saturation, lightness)
  - [HSV](https://en.wikipedia.org/wiki/HSL_and_HSV) (hue, saturation, value)


  ```bash
  pip install colouration
  ```




  ```python
  from colouration import Colour

  default_arguments = Colour(
  	obj=None,
  	red=None, green=None, blue=None,
  	hexadecimal=None,
  	hue=None, saturation=None, lightness=None, value=None,
  	min_value=0.0, max_value=1.0,
  	name=None, id=None, scheme=None,
  	weight=1.0
  )


  red = Colour('#FF0000')


  green = Colour(red=0, green=1, blue=0)


  blue = Colour(red=0, green=0, blue=255, max_value=255)


  literal_red = Colour('red')
  print(f'is red equal to literal_red? {"yes" if red == literal_red else "no"}\n')


  literal_red.print('by default the main colour is used for background\n')


  red.print(string='red text\n', main_colour='text', secondary='auto') # secondary='auto' is default


  red.print(string='the secondary colour is white when the main colour is dark and it is black otherwise.\n')


  red.print(string='red on white\n', main_colour='text', secondary='white')


  red.print(string='blue on red\n', secondary=Colour('blue'))


  dark_red = red.darken(ratio=0.5)
  dark_red.print(string='dark red\n')


  light_red = red.lighten(ratio=0.8)


  new_colour = red.increase_hue(0.2)
  new_colour.print('hue increased by 0.2\n')


  new_colour.red = 0.2
  new_colour.print('setting red = 0.2 causes this.\n')
  new_colour.hue = 0.8
  new_colour.print('setting hue = 0.4 causes this.\n')
  new_colour.value = 0.3
  new_colour.print('setting value = 0.3 causes this.\n')
  new_colour.lightness = 0.9
  new_colour.print('setting lightness = 0.9 causes this.\n')


  yellow = green + red
  yellow.print(string='mixing green and red produces this.\n')


  bluish = Colour(red=220, green=243, blue=255, max_value=255) # max_value is 1 by default
  bluish.print(string=f'Colour finds the best name for itself: {bluish.name}.\n')
  ```


pkgId: 7641c0cf3b9916abc594dc79058e9763f214f886919582051e11b5b8d55e21fa
name: python-colouredlogs
arch: src
version: 10.0.1
epoch: 0
release: 1
summary: Coloured terminal output for Python's logging module
url: https://colouredlogs.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colouredlogs-10.0.1-1.src.rpm
checksum_type: sha256
description:
  NOTE: This is a parody of the great `python-colouredlogs`_ project
  by Peter Odding. Please use that package as I currently have no
  plans to maintain this one. All I've done is `s/color/colour/g`.
  The `colouredlogs` package enables coloured terminal output for Python's logging_
  module. The ColouredFormatter_ class inherits from `logging.Formatter`_ and uses
  `ANSI escape sequences`_ to render your logging messages in colour. It uses only
  standard colours so it should work on any UNIX terminal. It's currently tested
  on Python 2.6, 2.7, 3.4, 3.5, 3.6 and PyPy. On Windows `colouredlogs`
  automatically pulls in Colourama_ as a dependency and enables ANSI escape
  sequence translation using Colourama. Here is a screen shot of the demo that is
  printed when the command ``colouredlogs --demo`` is executed:
  Note that the screenshot above includes custom logging levels defined by my
  verboselogs_ package: if you install both `colouredlogs` and `verboselogs` it
  will Just Work (`verboselogs` is of course not required to use
  `colouredlogs`).


pkgId: 4af4b3c91ca23b42c37b8c1d5964a81d463b44521fa8790a1ef7f9a99516423f
name: python-colourfulprint
arch: src
version: 7.0
epoch: 0
release: 1
summary: Colourfulprint wfor Rainbow print without extra newline character(
url: https://github.com/Nishant2009/colourfulprint
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colourfulprint-7.0-1.src.rpm
checksum_type: sha256
description:
  ColourfulPrint for rainbow colours in Linux without extra newline character ("\n").


  Run these commands to clone and run ColourfulPrint.
  ```shell script
  pkg install git -y
  pkg install python -y
  pip install colourfulprint
  ```


  Type
  ```shell script
  date | colourfulprint
  ```


pkgId: 73d32d400620fd8efe5f908041c9817c1538c8060d931dcc54e8b48b21ec63ae
name: python-colourmap
arch: src
version: 1.1.17
epoch: 0
release: 1
summary: Python package colourmap generates an N unique colors from the specified input colormap.
url: https://erdogant.github.io/colourmap
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colourmap-1.1.17-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/pypi/pyversions/colourmap)](https://img.shields.io/pypi/pyversions/colourmap)
  [![PyPI Version](https://img.shields.io/pypi/v/colourmap)](https://pypi.org/project/colourmap/)
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/erdogant/colourmap/blob/master/LICENSE)
  [![Github Forks](https://img.shields.io/github/forks/erdogant/colourmap.svg)](https://github.com/erdogant/colourmap/network)
  [![GitHub Open Issues](https://img.shields.io/github/issues/erdogant/colourmap.svg)](https://github.com/erdogant/colourmap/issues)
  [![Project Status](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
  [![Downloads](https://static.pepy.tech/badge/colourmap/month)](https://pepy.tech/project/colourmap)
  [![Downloads](https://pepy.tech/badge/colourmap)](https://pepy.tech/project/colourmap)
  [![Sphinx](https://img.shields.io/badge/Sphinx-Docs-Green)](https://erdogant.github.io/colourmap/)
  <!---[![BuyMeCoffee](https://img.shields.io/badge/buymea-coffee-yellow.svg)](https://www.buymeacoffee.com/erdogant)-->
  <!---[![Coffee](https://img.shields.io/badge/coffee-black-grey.svg)](https://erdogant.github.io/donate/?currency=USD&amount=5)-->

  *`` Colourmap`` generates an unique lit of RGB and HEX colors for the specified input list.



  **⭐️ Star this repo if you like it ⭐️**





  On the [documentation pages](https://erdogant.github.io/colourmap/) you can find more information about ``colourmap`` with examples.




  ```bash
  pip install colourmap     # normal install
  pip install -U colourmap  # update if needed
  ```



  ```python
  from colourmap import colourmap
  ```

  <hr>



  Use the documentation pages for more detailed usage. Some of the most used functionalities are linked below.


  ```python

  from colourmap import colourmap


  c = colourmap.generate(10)


  c_rgb, c_dict = colourmap.fromlist([1,1,2,2,3,1,2,3])


  c_hex = colourmap.rgb2hex(c_rgb)

  ```

























  <hr>


  * Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)
  * Contributions are welcome.
  * For citations, please use the citation at the right side panel.
  * If you wish to buy me a <a href="https://www.buymeacoffee.com/erdogant">Coffee</a> for this work, it is very appreciated :)


pkgId: 2a0eba69864a2ec0e707bd3fd578f7c5a228532aa6c41aa4ff83f138f034ec29
name: python-colpali-engine
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: The code used to train and run inference with the ColPali architecture.
url: https://pypi.org/project/colpali-engine/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colpali-engine-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [[Model card]](https://huggingface.co/vidore/colpali)
  [[ViDoRe Leaderboard]](https://huggingface.co/spaces/vidore/vidore-leaderboard)
  [[Demo]](https://huggingface.co/spaces/manu/ColPali-demo)
  [[Blog Post]](https://huggingface.co/blog/manu/colpali)
  > [!TIP]
  > For production usage in your RAG pipelines, we recommend using the [`byaldi`](https://github.com/AnswerDotAI/byaldi) package, which is a lightweight wrapper around the `colpali-engine` package developed by the author of the popular [RAGatouille](https://github.com/AnswerDotAI/RAGatouille) repostiory. 🐭

  This repository contains the code used for training the vision retrievers in the [*ColPali: Efficient Document Retrieval with Vision Language Models*](https://arxiv.org/abs/2407.01449) paper. In particular, it contains the code for training the ColPali model, which is a vision retriever based on the ColBERT architecture and the PaliGemma model.

  With our new model *ColPali*, we propose to leverage VLMs to construct efficient multi-vector embeddings in the visual space for document retrieval. By feeding the ViT output patches from PaliGemma-3B to a linear projection, we create a multi-vector representation of documents. We train the model to maximize the similarity between these document embeddings and the query embeddings, following the ColBERT method.
  Using ColPali removes the need for potentially complex and brittle layout recognition and OCR pipelines with a single model that can take into account both the textual and visual content (layout, charts, ...) of a document.
  ![ColPali Architecture](assets/colpali_architecture.webp)

  | Model                                                        | Score on [ViDoRe](https://huggingface.co/spaces/vidore/vidore-leaderboard) 🏆 | License    | Comments                                                     | Currently supported |
  | ------------------------------------------------------------ | ------------------------------------------------------------ | ---------- | ------------------------------------------------------------ | ------------------- |
  | [vidore/colpali](https://huggingface.co/vidore/colpali)      | 81.3                                                         | Gemma      | • Based on `google/paligemma-3b-mix-448`.<br />• Checkpoint used in the ColPali paper. | ❌                   |
  | [vidore/colpali-v1.1](https://huggingface.co/vidore/colpali-v1.1) | 81.5                                                         | Gemma      | • Based on `google/paligemma-3b-mix-448`.                    | ✅                   |
  | [vidore/colpali-v1.2](https://huggingface.co/vidore/colpali-v1.2) | 83.1                                                         | Gemma      | • Based on `google/paligemma-3b-mix-448`.                    | ✅                   |
  | [vidore/colqwen2-v0.1](https://huggingface.co/vidore/colqwen2-v0.1) | 86.6                                                         | Apache 2.0 | • Based on `Qwen/Qwen2-VL-2B-Instruct`.<br />• Supports dynamic resolution.<br />• Trained using 768 image patches per page. | ✅                   |

  We used Python 3.11.6 and PyTorch 2.2.2 to train and test our models, but the codebase is compatible with Python >=3.9 and recent PyTorch versions. To install the package, run:
  ```bash
  pip install colpali-engine
  ```
  > [!WARNING]
  > For ColPali versions above v1.0, make sure to install the `colpali-engine` package from source or with a version above v0.2.0.


  ```python
  import torch
  from PIL import Image
  from colpali_engine.models import ColPali, ColPaliProcessor
  model_name = "vidore/colpali-v1.2"
  model = ColPali.from_pretrained(
      model_name,
      torch_dtype=torch.bfloat16,
      device_map="cuda:0",  # or "mps" if on Apple Silicon
  ).eval()
  processor = ColPaliProcessor.from_pretrained(model_name)

  images = [
      Image.new("RGB", (32, 32), color="white"),
      Image.new("RGB", (16, 16), color="black"),
  ]
  queries = [
      "Is attention really all you need?",
      "Are Benjamin, Antoine, Merve, and Jo best friends?",
  ]

  batch_images = processor.process_images(images).to(model.device)
  batch_queries = processor.process_queries(queries).to(model.device)

  with torch.no_grad():
      image_embeddings = model(**batch_images)
      query_embeddings = model(**batch_queries)
  scores = processor.score_multi_vector(query_embeddings, image_embeddings)
  ```

  You can find an example [here](https://github.com/illuin-tech/colpali/blob/main/scripts/infer/run_inference_with_python.py). If you need an indexing system, we recommend using [`byaldi`](https://github.com/AnswerDotAI/byaldi) - [RAGatouille](https://github.com/AnswerDotAI/RAGatouille)'s little sister 🐭 - which share a similar API and leverages our `colpali-engine` package.

  To benchmark ColPali to reproduce the results on the [ViDoRe leaderboard](https://huggingface.co/spaces/vidore/vidore-leaderboard), it is recommended to use the [`vidore-benchmark`](https://github.com/illuin-tech/vidore-benchmark) package.

  By superimposing the late interaction similarity maps on top of the original image, we can visualize the most salient image patches with respect to each term of the query, yielding interpretable insights into model focus zones.
  To use the `interpretability` module, you need to install the `colpali-engine[interpretability]` package:
  ```bash
  pip install colpali-engine[interpretability]
  ```
  Then, after generating your embeddings with ColPali, use the following code to plot the similarity maps for each query token:
  ```python
  import torch
  from PIL import Image
  from colpali_engine.interpretability import (
      get_similarity_maps_from_embeddings,
      plot_all_similarity_maps,
  )
  from colpali_engine.models import ColPali, ColPaliProcessor
  from colpali_engine.utils.torch_utils import get_torch_device
  model_name = "vidore/colpali-v1.2"
  device = get_torch_device("auto")

  model = ColPali.from_pretrained(
      model_name,
      torch_dtype=torch.bfloat16,
      device_map=device,
  ).eval()

  processor = ColPaliProcessor.from_pretrained(model_name)

  image = Image.open("shift_kazakhstan.jpg")
  query = "Quelle partie de la production pétrolière du Kazakhstan provient de champs en mer ?"

  batch_images = processor.process_images([image]).to(device)
  batch_queries = processor.process_queries([query]).to(device)

  with torch.no_grad():
      image_embeddings = model.forward(**batch_images)
      query_embeddings = model.forward(**batch_queries)

  n_patches = processor.get_n_patches(image_size=image.size, patch_size=model.patch_size)

  image_mask = processor.get_image_mask(batch_images)

  batched_similarity_maps = get_similarity_maps_from_embeddings(
      image_embeddings=image_embeddings,
      query_embeddings=query_embeddings,
      n_patches=n_patches,
      image_mask=image_mask,
  )

  similarity_maps = batched_similarity_maps[0]  # (query_length, n_patches_x, n_patches_y)

  query_tokens = processor.tokenizer.tokenize(query)

  plots = plot_all_similarity_maps(
      image=image,
      query_tokens=query_tokens,
      similarity_maps=similarity_maps,
  )
  for idx, (fig, ax) in enumerate(plots):
      fig.savefig(f"similarity_map_{idx}.png")
  ```
  For a more detailed example, you can refer to the interpretability notebooks from the [ColPali Cookbooks 👨🏻‍🍳](https://github.com/tonywu71/colpali-cookbooks) repository.

  To keep a lightweight repository, only the essential packages were installed. In particular, you must specify the dependencies to use the training script for ColPali. You can do this using the following command:
  ```bash
  pip install "colpali-engine[train]"
  ```
  All the model configs used can be found in `scripts/configs/` and rely on the [configue](https://github.com/illuin-tech/configue) package for straightforward configuration. They should be used with the `train_colbert.py` script.

  ```bash
  USE_LOCAL_DATASET=0 python scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml
  ```
  or using `accelerate`:
  ```bash
  accelerate launch scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml
  ```

  ```bash
  sbatch --nodes=1 --cpus-per-task=16 --mem-per-cpu=32GB --time=20:00:00 --gres=gpu:1  -p gpua100 --job-name=colidefics --output=colidefics.out --error=colidefics.err --wrap="accelerate launch scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml"
  sbatch --nodes=1  --time=5:00:00 -A cad15443 --gres=gpu:8  --constraint=MI250 --job-name=colpali --wrap="python scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml"
  ```

  To reproduce the results from the paper, you should checkout to the `v0.1.1` tag or install the corresponding `colpali-engine` package release using:
  ```bash
  pip install colpali-engine==0.1.1
  ```

  **ColPali: Efficient Document Retrieval with Vision Language Models**
  Authors: **Manuel Faysse**\*, **Hugues Sibille**\*, **Tony Wu**\*, Bilel Omrani, Gautier Viaud, Céline Hudelot, Pierre Colombo (\* denotes equal contribution)
  ```latex
  @misc{faysse2024colpaliefficientdocumentretrieval,
        title={ColPali: Efficient Document Retrieval with Vision Language Models},
        author={Manuel Faysse and Hugues Sibille and Tony Wu and Bilel Omrani and Gautier Viaud and Céline Hudelot and Pierre Colombo},
        year={2024},
        eprint={2407.01449},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.01449},
  }
  ```


pkgId: 1e7e19b06cddac3b99a4a0e160dc2a4b009b63687c7491d1cfa841cb23c9d2bf
name: python-colpali-engine
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: The code used to train and run inference with the ColPali architecture.
url: https://pypi.org/project/colpali-engine/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colpali-engine-0.3.4-1.src.rpm
checksum_type: sha256
description:
  [[Model card]](https://huggingface.co/vidore/colpali)
  [[ViDoRe Leaderboard]](https://huggingface.co/spaces/vidore/vidore-leaderboard)
  [[Demo]](https://huggingface.co/spaces/manu/ColPali-demo)
  [[Blog Post]](https://huggingface.co/blog/manu/colpali)

  This repository contains the code used for training the vision retrievers in the [*ColPali: Efficient Document Retrieval with Vision Language Models*](https://arxiv.org/abs/2407.01449) paper. In particular, it contains the code for training the ColPali model, which is a vision retriever based on the ColBERT architecture and the PaliGemma model.

  With our new model *ColPali*, we propose to leverage VLMs to construct efficient multi-vector embeddings in the visual space for document retrieval. By feeding the ViT output patches from PaliGemma-3B to a linear projection, we create a multi-vector representation of documents. We train the model to maximize the similarity between these document embeddings and the query embeddings, following the ColBERT method.
  Using ColPali removes the need for potentially complex and brittle layout recognition and OCR pipelines with a single model that can take into account both the textual and visual content (layout, charts, ...) of a document.
  ![ColPali Architecture](assets/colpali_architecture.webp)

  | Model                                                        | Score on [ViDoRe](https://huggingface.co/spaces/vidore/vidore-leaderboard) 🏆 | License    | Comments                                                     | Currently supported |
  | ------------------------------------------------------------ |-------------------------------------------------------------------------------| ---------- | ------------------------------------------------------------ | ------------------- |
  | [vidore/colpali](https://huggingface.co/vidore/colpali)      | 81.3                                                                          | Gemma      | • Based on `google/paligemma-3b-mix-448`.<br />• Checkpoint used in the ColPali paper. | ❌                   |
  | [vidore/colpali-v1.1](https://huggingface.co/vidore/colpali-v1.1) | 81.5                                                                          | Gemma      | • Based on `google/paligemma-3b-mix-448`.                    | ✅                   |
  | [vidore/colpali-v1.2](https://huggingface.co/vidore/colpali-v1.2) | 83.9                                                                          | Gemma      | • Based on `google/paligemma-3b-mix-448`.                    | ✅                   |
  | [vidore/colqwen2-v0.1](https://huggingface.co/vidore/colqwen2-v0.1) | 87.3                                                                          | Apache 2.0 | • Based on `Qwen/Qwen2-VL-2B-Instruct`.<br />• Supports dynamic resolution.<br />• Trained using 768 image patches per page. | ✅                   |

  We used Python 3.11.6 and PyTorch 2.4 to train and test our models, but the codebase is compatible with Python >=3.9 and recent PyTorch versions. To install the package, run:
  ```bash
  pip install colpali-engine
  ```
  > [!WARNING]
  > For ColPali versions above v1.0, make sure to install the `colpali-engine` package from source or with a version above v0.2.0.


  ```python
  import torch
  from PIL import Image
  from colpali_engine.models import ColQwen2, ColQwen2Processor
  model_name = "vidore/colqwen2-v0.1"
  model = ColQwen2.from_pretrained(
      model_name,
      torch_dtype=torch.bfloat16,
      device_map="cuda:0",  # or "mps" if on Apple Silicon
  ).eval()
  processor = ColQwen2Processor.from_pretrained(model_name)

  images = [
      Image.new("RGB", (32, 32), color="white"),
      Image.new("RGB", (16, 16), color="black"),
  ]
  queries = [
      "Is attention really all you need?",
      "Are Benjamin, Antoine, Merve, and Jo best friends?",
  ]

  batch_images = processor.process_images(images).to(model.device)
  batch_queries = processor.process_queries(queries).to(model.device)

  with torch.no_grad():
      image_embeddings = model(**batch_images)
      query_embeddings = model(**batch_queries)
  scores = processor.score_multi_vector(query_embeddings, image_embeddings)
  ```

  You can find an example [here](https://github.com/illuin-tech/colpali/blob/main/scripts/infer/run_inference_with_python.py).

  To benchmark ColPali to reproduce the results on the [ViDoRe leaderboard](https://huggingface.co/spaces/vidore/vidore-leaderboard), it is recommended to use the [`vidore-benchmark`](https://github.com/illuin-tech/vidore-benchmark) package.

  By superimposing the late interaction similarity maps on top of the original image, we can visualize the most salient image patches with respect to each term of the query, yielding interpretable insights into model focus zones.
  To use the `interpretability` module, you need to install the `colpali-engine[interpretability]` package:
  ```bash
  pip install colpali-engine[interpretability]
  ```
  Then, after generating your embeddings with ColPali, use the following code to plot the similarity maps for each query token:
  ```python
  import torch
  from PIL import Image
  from colpali_engine.interpretability import (
      get_similarity_maps_from_embeddings,
      plot_all_similarity_maps,
  )
  from colpali_engine.models import ColPali, ColPaliProcessor
  from colpali_engine.utils.torch_utils import get_torch_device
  model_name = "vidore/colpali-v1.2"
  device = get_torch_device("auto")

  model = ColPali.from_pretrained(
      model_name,
      torch_dtype=torch.bfloat16,
      device_map=device,
  ).eval()

  processor = ColPaliProcessor.from_pretrained(model_name)

  image = Image.open("shift_kazakhstan.jpg")
  query = "Quelle partie de la production pétrolière du Kazakhstan provient de champs en mer ?"

  batch_images = processor.process_images([image]).to(device)
  batch_queries = processor.process_queries([query]).to(device)

  with torch.no_grad():
      image_embeddings = model.forward(**batch_images)
      query_embeddings = model.forward(**batch_queries)

  n_patches = processor.get_n_patches(image_size=image.size, patch_size=model.patch_size)

  image_mask = processor.get_image_mask(batch_images)

  batched_similarity_maps = get_similarity_maps_from_embeddings(
      image_embeddings=image_embeddings,
      query_embeddings=query_embeddings,
      n_patches=n_patches,
      image_mask=image_mask,
  )

  similarity_maps = batched_similarity_maps[0]  # (query_length, n_patches_x, n_patches_y)

  query_tokens = processor.tokenizer.tokenize(query)

  plots = plot_all_similarity_maps(
      image=image,
      query_tokens=query_tokens,
      similarity_maps=similarity_maps,
  )
  for idx, (fig, ax) in enumerate(plots):
      fig.savefig(f"similarity_map_{idx}.png")
  ```
  For a more detailed example, you can refer to the interpretability notebooks from the [ColPali Cookbooks 👨🏻‍🍳](https://github.com/tonywu71/colpali-cookbooks) repository.

  To keep a lightweight repository, only the essential packages were installed. In particular, you must specify the dependencies to use the training script for ColPali. You can do this using the following command:
  ```bash
  pip install "colpali-engine[train]"
  ```
  All the model configs used can be found in `scripts/configs/` and rely on the [configue](https://github.com/illuin-tech/configue) package for straightforward configuration. They should be used with the `train_colbert.py` script.

  ```bash
  USE_LOCAL_DATASET=0 python scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml
  ```
  or using `accelerate`:
  ```bash
  accelerate launch scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml
  ```

  ```bash
  sbatch --nodes=1 --cpus-per-task=16 --mem-per-cpu=32GB --time=20:00:00 --gres=gpu:1  -p gpua100 --job-name=colidefics --output=colidefics.out --error=colidefics.err --wrap="accelerate launch scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml"
  sbatch --nodes=1  --time=5:00:00 -A cad15443 --gres=gpu:8  --constraint=MI250 --job-name=colpali --wrap="python scripts/train/train_colbert.py scripts/configs/pali/train_colpali_docmatix_hardneg_model.yaml"
  ```

  Several community projects and ressources have been developed around ColPali to facilitate its usage. Feel free to reach out if you want to add your project to this list!

  | Library Name  | Description                                                  |
  | ------------- | ------------------------------------------------------------ |
  | Byaldi        | [`Byaldi`](https://github.com/AnswerDotAI/byaldi) is [RAGatouille](https://github.com/AnswerDotAI/RAGatouille)'s equivalent for ColPali, leveraging the `colpali-engine` package to facilitate indexing and storing embeddings. |
  | PyVespa       | [`PyVespa`](https://pyvespa.readthedocs.io/en/latest/examples/colpali-document-retrieval-vision-language-models-cloud.html) allows interaction with [Vespa](https://vespa.ai/), a production-grade vector database, with detailed ColPali support. |
  | Candle        | [Candle](https://github.com/huggingface/candle/tree/main/candle-examples/examples/colpali) enables ColPali inference with an efficient ML framework for Rust. |
  | DocAI         | [DocAI](https://github.com/PragmaticMachineLearning/docai) uses ColPali with GPT-4o and Langchain to extract structured information from documents. |
  | VARAG         | [VARAG](https://github.com/adithya-s-k/VARAG) uses ColPali in a vision-only and a hybrid RAG pipeline. |
  | ColBERT Live! | [`ColBERT Live!`](https://github.com/jbellis/colbert-live/) enables ColPali usage with vector databases supporting large datasets, compression, and non-vector predicates. |

  | Notebook Title                                    | Author & Link                                                                                                                                  |
  |---------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------|
  | ColPali Cookbooks                                 | [Tony's Cookbooks (ILLUIN)](https://github.com/tonywu71/colpali-cookbooks) 🙋🏻                                                                |
  | Vision RAG Tutorial                               | [Manu's Vision Rag Tutorial (ILLUIN)](https://github.com/ManuelFay/Tutorials/blob/main/Tuesday_Practical_2_Vision_RAG.ipynb) 🙋🏻              |
  | ColPali (Byaldi) + Qwen2-VL for RAG               | [Merve's Notebook (HuggingFace 🤗)](https://github.com/merveenoyan/smol-vision/blob/main/ColPali_%2B_Qwen2_VL.ipynb)                           |
  | Indexing ColPali with Qdrant                      | [Daniel's Notebook (HuggingFace 🤗)](https://danielvanstrien.xyz/posts/post-with-code/colpali-qdrant/2024-10-02_using_colpali_with_qdrant.html) |
  | Weaviate Tutorial                                 | [Connor's ColPali POC (Weaviate)](https://github.com/weaviate/recipes/blob/main/weaviate-features/named-vectors/NamedVectors-ColPali-POC.ipynb) |
  | Use ColPali for Multi-Modal Retrieval with Milvus | [Milvus Documentation](https://milvus.io/docs/use_ColPali_with_milvus.md)                                                              |
  | Data Generation                                   | [Daniel's Notebook (HuggingFace 🤗)](https://danielvanstrien.xyz/posts/post-with-code/colpali/2024-09-23-generate_colpali_dataset.html)        |
  | Finance Report Analysis with ColPali and Gemini   | [Jaykumaran (LearnOpenCV)](https://github.com/spmallick/learnopencv/tree/master/Multimodal-RAG-with-ColPali-Gemini)                            |

  - 📝 = blog post
  - 📋 = PDF / slides
  - 📹 = video
  | Title                                                                                    | Author & Link                                                                                                                                                 |
  |------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | State of AI report 2024                                                                  | [Nathan's report](https://www.stateof.ai/) 📋                                                                                                                 |
  | Technology Radar Volume 31 (October 2024)                                                | [thoughtworks's report](https://www.thoughtworks.com/radar) 📋                                                                                                |
  | LlamaIndex Webinar: ColPali - Efficient Document Retrieval with Vision Language Models   | [LlamaIndex's Youtube video](https://youtu.be/nzcBvba7mzI?si=WL9MsyiAFJMyEolz) 📹                                                                             |
  | PDF Retrieval with Vision Language Models                                                | [Jo's blog post #1 (Vespa)](https://blog.vespa.ai/retrieval-with-vision-language-models-colpali/) 📝                                                          |
  | Scaling ColPali to billions of PDFs with Vespa                                           | [Jo's blog post #2 (Vespa)](https://blog.vespa.ai/scaling-colpali-to-billions/) 📝                                                                            |
  | Neural Search Talks: ColPali (with Manuel Faysse)                                        | [Zeta Alpha's Podcast](https://open.spotify.com/episode/2s6ljhd6VQTL2mIU9cFzCb) 📹                                                                            |
  | Multimodal Document RAG with Llama 3.2 Vision and ColQwen2                               | [Zain's blog post (Together AI)](https://www.together.ai/blog/multimodal-document-rag-with-llama-3-2-vision-and-colqwen2) 📝                                  |
  | ColPali: Document Retrieval with Vision Language Models                                  | [Antaripa Saha](https://antaripasaha.notion.site/ColPali-Efficient-Document-Retrieval-with-Vision-Language-Models-10f5314a5639803d94d0d7ac191bb5b1) 📝        |
  | Minimalist diagrams explaining ColPali                                                   | [Leonie's ColPali diagrams on X ](https://twitter.com/helloiamleonie/status/1839321865195851859)📝                                                            |
  | Multimodal RAG with ColPali and Gemini : Financial Report Analysis Application           | [Jaykumaran's blog post (LearnOpenCV)](https://learnopencv.com/multimodal-rag-with-colpali/) 📝                                                               |
  | Implement Multimodal RAG with ColPali and Vision Language Model Groq(Llava) and Qwen2-VL | [Plaban's blog post](https://medium.com/the-ai-forum/implement-multimodal-rag-with-colpali-and-vision-language-model-groq-llava-and-qwen2-vl-5c113b8c08fd) 📝 |
  | multimodal AI. open-source. in a nutshell.                                               | [Merve's Youtube video](https://youtu.be/IoGaGfU1CIg?si=yEhxMqJYxvMzGyUm) 📹                                                                                  |
  | Remove Complexity from Your RAG Applications                                             | [Kyryl's blog post (KOML)](https://kyrylai.com/2024/09/09/remove-complexity-from-your-rag-applications/) 📝                                                   |
  | Late interaction & efficient Multi-modal retrievers need more than a vector index        | [Ayush Chaurasia (LanceDB)](https://blog.lancedb.com/late-interaction-efficient-multi-modal-retrievers-need-more-than-just-a-vector-index/) 📝                |
  | Optimizing Document Retrieval with ColPali and Qdrant's Binary Quantization              | [Sabrina Aquino (Qdrant)]( https://youtu.be/_A90A-grwIc?si=MS5RV17D6sgirCRm)  📹                                                                              |
  | Hands-On Multimodal Retrieval and Interpretability (ColQwen + Vespa)                     | [Antaripa Saha](https://www.analyticsvidhya.com/blog/2024/10/multimodal-retrieval-with-colqwen-vespa/) 📝                                                     |

  To reproduce the results from the paper, you should checkout to the `v0.1.1` tag or install the corresponding `colpali-engine` package release using:
  ```bash
  pip install colpali-engine==0.1.1
  ```

  **ColPali: Efficient Document Retrieval with Vision Language Models**
  Authors: **Manuel Faysse**\*, **Hugues Sibille**\*, **Tony Wu**\*, Bilel Omrani, Gautier Viaud, Céline Hudelot, Pierre Colombo (\* denotes equal contribution)
  ```latex
  @misc{faysse2024colpaliefficientdocumentretrieval,
        title={ColPali: Efficient Document Retrieval with Vision Language Models},
        author={Manuel Faysse and Hugues Sibille and Tony Wu and Bilel Omrani and Gautier Viaud and Céline Hudelot and Pierre Colombo},
        year={2024},
        eprint={2407.01449},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2407.01449},
  }
  ```


pkgId: f0b59e1a4877d731b0060707a06cf6fb04ae268e5291c946925f1a7488609b01
name: python-colrag
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A RAG pipeline using ColBERT via RAGatouille
url: https://syedzaidi-kiwi.github.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colrag-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <sub>Built with ❤️ by <a href="https://github.com/syedzaidi-kiwi">your username</a></sub>
  </div>


pkgId: c5f69902a1e84d4c3f055a82924fae54bb9c2b78e1d592a82b94a3c7e052c539
name: python-colrev
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: CoLRev: An open-source environment for collaborative reviews
url: https://colrev-environment.github.io/colrev/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colrev-0.13.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="https://raw.githubusercontent.com/CoLRev-Ecosystem/colrev/main/docs/figures/logo_small.png" width="400">
  </p>

  <div align="center">

  [![DOI](https://zenodo.org/badge/363073613.svg)](https://zenodo.org/badge/latestdoi/363073613)
  [![GitHub release](https://img.shields.io/github/v/release/CoLRev-Ecosystem/colrev.svg)](https://github.com/CoLRev-Environment/colrev/releases/)
  [![PyPI - Version](https://img.shields.io/pypi/v/colrev?color=blue)](https://pypi.org/project/colrev/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/colrev)
  [![License](https://img.shields.io/github/license/CoLRev-Ecosystem/colrev.svg)](https://github.com/CoLRev-Environment/colrev/releases/)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  ![Documentation Status](https://img.shields.io/github/actions/workflow/status/CoLRev-Ecosystem/colrev/docs_deploy.yml?label=documentation)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/CoLRev-Ecosystem/colrev/tests.yml?label=tests)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/CoLRev-Ecosystem/colrev/main.svg)](https://results.pre-commit.ci/latest/github/CoLRev-Ecosystem/colrev/main)
  ![Coverage](https://raw.githubusercontent.com/CoLRev-Ecosystem/colrev/main/tests/coverage.svg)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/bd4e44c6cda646e4b9e494c4c4d9487b)](https://app.codacy.com/gh/CoLRev-Environment/colrev/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
  ![GitHub last commit](https://img.shields.io/github/last-commit/CoLRev-Ecosystem/colrev)
  [![Downloads](https://static.pepy.tech/badge/colrev/month)](https://pepy.tech/project/colrev)
  [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7148/badge)](https://bestpractices.coreinfrastructure.org/projects/7148)
  [![SWH](https://archive.softwareheritage.org/badge/origin/https://github.com/CoLRev-Environment/colrev/)](https://archive.softwareheritage.org/browse/origin/?origin_url=https://github.com/CoLRev-Environment/colrev/)<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-32-green.svg?style=flat-square)](#contributors)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->
  <!-- ![PyPI](https://img.shields.io/pypi/v/colrev) -->

  </div>



  CoLRev is an open-source environment for collaborative literature reviews. It integrates with differerent synthesis tools, takes care of the data, and facilitates Git-based collaboration.

  To accomplish these goals, CoLRev advances the design of review technology at the intersection of methods, design, cognition, and community building.
  The following features stand out:

  - Supports all literature review steps: problem formulation, search, dedupe, (pre)screen, pdf retrieval and preparation, and synthesis
  - An open and extensible environment based on shared data and process standards
  - Builds on git and its transparent collaboration model for the entire literature review process
  - Offers a self-explanatory, fault-tolerant, and configurable user workflow
  - Operates a model for data quality, content curation, and reuse
  - Enables typological and methodological pluralism throughout the process

  ![Demo](docs/source/_static/demo.gif)

  For details, consult the [documentation](https://colrev-environment.github.io/colrev/).



  You can try a live demonstration of CoLRev via GitHub codespaces: [start demo](https://github.com//codespaces/new?hide_repo_select=true&ref=main&repo=767717822).



  Contributions, code and features are always welcome

  - See [contributing guidelines](CONTRIBUTING.md), [help page](https://colrev-environment.github.io/colrev/manual/help.html), and [github repository](https://github.com/CoLRev-Environment/colrev).
  - Bug reports or feedback? Please use the [issue tracker](https://github.com/CoLRev-Environment/colrev/issues) and let us know.
  - To get your work included, fork the repository, implement your changes, and create a [pull request](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests).

  For further information, see [tests](tests/readme.md), [changes](CHANGELOG.md), and [releases](https://github.com/CoLRev-Environment/colrev/releases).



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/geritwagner"><img src="https://avatars.githubusercontent.com/u/3872815?v=4?s=100" width="100px;" alt="Gerit Wagner"/><br /><sub><b>Gerit Wagner</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=geritwagner" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=geritwagner" title="Documentation">📖</a> <a href="#data-geritwagner" title="Data">🔣</a> <a href="#content-geritwagner" title="Content">🖋</a> <a href="#example-geritwagner" title="Examples">💡</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://julianprester.com"><img src="https://avatars.githubusercontent.com/u/4706870?v=4?s=100" width="100px;" alt="Julian Prester"/><br /><sub><b>Julian Prester</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=julianprester" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=julianprester" title="Documentation">📖</a> <a href="#data-julianprester" title="Data">🔣</a> <a href="#content-julianprester" title="Content">🖋</a> <a href="https://github.com/CoLRev-Environment/colrev/issues?q=author%3Ajulianprester" title="Bug reports">🐛</a> <a href="#ideas-julianprester" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tmahmood"><img src="https://avatars.githubusercontent.com/u/34904?v=4?s=100" width="100px;" alt="Tarin Mahmood"/><br /><sub><b>Tarin Mahmood</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=tmahmood" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=tmahmood" title="Tests">⚠️</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=tmahmood" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dengdenglele"><img src="https://avatars.githubusercontent.com/u/28404427?v=4?s=100" width="100px;" alt="dengdenglele"/><br /><sub><b>dengdenglele</b></sub></a><br /><a href="#data-dengdenglele" title="Data">🔣</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=dengdenglele" title="Documentation">📖</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=dengdenglele" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mhlbrsimon"><img src="https://avatars.githubusercontent.com/u/83401831?v=4?s=100" width="100px;" alt="mhlbrsimon"/><br /><sub><b>mhlbrsimon</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=mhlbrsimon" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ossendorfluca"><img src="https://avatars.githubusercontent.com/u/112037612?v=4?s=100" width="100px;" alt="ossendorfluca"/><br /><sub><b>ossendorfluca</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=ossendorfluca" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/katharinaernst"><img src="https://avatars.githubusercontent.com/u/131549085?v=4?s=100" width="100px;" alt="katharinaernst"/><br /><sub><b>katharinaernst</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=katharinaernst" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/einfachjessi"><img src="https://avatars.githubusercontent.com/u/131001755?v=4?s=100" width="100px;" alt="einfachjessi"/><br /><sub><b>einfachjessi</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=einfachjessi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Janus678"><img src="https://avatars.githubusercontent.com/u/131582517?v=4?s=100" width="100px;" alt="Janus678"/><br /><sub><b>Janus678</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=Janus678" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/frxdericz"><img src="https://avatars.githubusercontent.com/u/131789939?v=4?s=100" width="100px;" alt="frxdericz"/><br /><sub><b>frxdericz</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=frxdericz" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/MalouSchmidt"><img src="https://avatars.githubusercontent.com/u/131263679?v=4?s=100" width="100px;" alt="MalouSchmidt"/><br /><sub><b>MalouSchmidt</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=MalouSchmidt" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/RheaDoesStuff"><img src="https://avatars.githubusercontent.com/u/74066245?v=4?s=100" width="100px;" alt="RheaDoesStuff"/><br /><sub><b>RheaDoesStuff</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=RheaDoesStuff" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Cohen2000"><img src="https://avatars.githubusercontent.com/u/113113352?v=4?s=100" width="100px;" alt="Cohen2000"/><br /><sub><b>Cohen2000</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=Cohen2000" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/RobertAhr"><img src="https://avatars.githubusercontent.com/u/131687952?v=4?s=100" width="100px;" alt="RobertAhr"/><br /><sub><b>RobertAhr</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=RobertAhr" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ThomasFleischmann"><img src="https://avatars.githubusercontent.com/u/131684139?v=4?s=100" width="100px;" alt="ThomasFleischmann"/><br /><sub><b>ThomasFleischmann</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=ThomasFleischmann" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/AntonFrisch"><img src="https://avatars.githubusercontent.com/u/131719653?v=4?s=100" width="100px;" alt="AntonFrisch"/><br /><sub><b>AntonFrisch</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=AntonFrisch" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/LouisLangenhan"><img src="https://avatars.githubusercontent.com/u/148447366?v=4?s=100" width="100px;" alt="LouisLangenhan"/><br /><sub><b>LouisLangenhan</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=LouisLangenhan" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=LouisLangenhan" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Peteer98"><img src="https://avatars.githubusercontent.com/u/148191162?v=4?s=100" width="100px;" alt="Peter Eckhardt"/><br /><sub><b>Peter Eckhardt</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=Peteer98" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=Peteer98" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/user123projekt"><img src="https://avatars.githubusercontent.com/u/149078858?v=4?s=100" width="100px;" alt="User123projekt"/><br /><sub><b>User123projekt</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=User123projekt" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=User123projekt" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/LuminousLynx"><img src="https://avatars.githubusercontent.com/u/148456911?v=4?s=100" width="100px;" alt="LuminousLynx"/><br /><sub><b>LuminousLynx</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=LuminousLynx" title="Code">💻</a> <a href="https://github.com/CoLRev-Environment/colrev/commits?author=LuminousLynx" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/koljarinne"><img src="https://avatars.githubusercontent.com/u/167416691?v=4?s=100" width="100px;" alt="koljarinne"/><br /><sub><b>koljarinne</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=koljarinne" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/k-schnickmann"><img src="https://avatars.githubusercontent.com/u/168131195?v=4?s=100" width="100px;" alt="Karl Schnickmann"/><br /><sub><b>Karl Schnickmann</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=k-schnickmann" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/edensarrival"><img src="https://avatars.githubusercontent.com/u/42614229?v=4?s=100" width="100px;" alt="edensarrival"/><br /><sub><b>edensarrival</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=edensarrival" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/U1TIM4T3"><img src="https://avatars.githubusercontent.com/u/167421727?v=4?s=100" width="100px;" alt="U1TIM4T3"/><br /><sub><b>U1TIM4T3</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=U1TIM4T3" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/annaglr"><img src="https://avatars.githubusercontent.com/u/76491696?v=4?s=100" width="100px;" alt="Anna Geßler"/><br /><sub><b>annaglr</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=annaglr" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/0xmtyset"><img src="https://avatars.githubusercontent.com/u/160525679?v=4?s=100" width="100px;" alt="0xmtyset"/><br /><sub><b>0xmtyset</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=0xmtyset" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tobiaspffl"><img src="https://avatars.githubusercontent.com/u/134608287?v=4?s=100" width="100px;" alt="tobiaspffl"/><br /><sub><b>tobiaspffl</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=tobiaspffl" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/CelinaSchwarz"><img src="https://avatars.githubusercontent.com/u/71493743?v=4?s=100" width="100px;" alt="CelinaSchwarz"/><br /><sub><b>CelinaSchwarz</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=CelinaSchwarz" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/QuynhMaiNguyen"><img src="https://avatars.githubusercontent.com/u/167417535?v=4?s=100" width="100px;" alt="QuynhMaiNguyen"/><br /><sub><b>QuynhMaiNguyen</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=QuynhMaiNguyen" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/pmao0907"><img src="https://avatars.githubusercontent.com/u/167312265?v=4?s=100" width="100px;" alt="pmao0907"/><br /><sub><b>pmao0907</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=pmao0907" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/MingxinJiang"><img src="https://avatars.githubusercontent.com/u/132772605?v=4?s=100" width="100px;" alt="MingxinJiang"/><br /><sub><b>MingxinJiang</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=MingxinJiang" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JohannesDiel"><img src="https://avatars.githubusercontent.com/u/167763043?v=4?s=100" width="100px;" alt="JohannesDiel"/><br /><sub><b>JohannesDiel</b></sub></a><br /><a href="https://github.com/CoLRev-Environment/colrev/commits?author=JohannesDiel" title="Code">💻</a></td>
      </tr>
    </tbody>
  </table>

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

  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->

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

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



  This project is distributed under the [MIT License](LICENSE) the documentation is distributed under the [CC-0](https://creativecommons.org/publicdomain/zero/1.0/) license.
  If you contribute to the project, you agree to share your contribution following these licenses.



  Please cite the project as follows:

  Wagner, G. and Prester, J. (2024) CoLRev - An open-source environment for Collaborative Literature Reviews. Available at https://github.com/CoLRev-Environment/colrev. doi:[10.5281/zenodo.11668338](https://dx.doi.org/10.5281/zenodo.11668338)


pkgId: 1b6792878520b76bd0e459d49e2097d645f46301e36080158473d09cc1696d34
name: python-colt
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: A configuration utility for Python object.
url: https://github.com/altescy/colt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colt-0.14.0-1.src.rpm
checksum_type: sha256
description:
  [![CI Actions Status](https://github.com/altescy/colt/workflows/CI/badge.svg)](https://github.com/altescy/colt/actions?query=workflow%3ACI)
  [![Pulish Actions Status](https://github.com/altescy/colt/workflows/publish/badge.svg)](https://github.com/altescy/colt/actions?query=workflow%3Apublish)
  [![Python version](https://img.shields.io/pypi/pyversions/colt)](https://github.com/altescy/colt)
  [![pypi version](https://img.shields.io/pypi/v/colt)](https://pypi.org/project/colt/)
  [![license](https://img.shields.io/github/license/altescy/colt)](https://github.com/altescy/colt/blob/master/LICENSE)

  Effortlessly configure and construct Python objects with `colt`, a lightweight library inspired by [AllenNLP](https://github.com/allenai/allennlp) and [Tango](https://github.com/allenai/tango)



  - [Introduction](#introduction)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Influences](#influences)
  - [kaggle Titanic Example](https://github.com/altescy/colt/tree/master/examples/titanic)



  `colt` is a lightweight configuration utility for Python objects, allowing you to manage complex configurations for your projects easily.
  Written solely using the Python standard library, `colt` can construct class objects from JSON-convertible dictionaries, making it simple to manage your settings using JSON or YAML files. The library is particularly suitable for the [dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) design pattern.

  Some key features of colt include:

  - No external dependencies, as it is built using the Python standard library.
  - Construct class objects from JSON-convertible dictionaries.
  - Manage complex configurations using JSON or YAML files.
  - Well-suited for dependency injection design patterns.

  Inspired by [AllenNLP](https://github.com/allenai/allennlp) and [Tango](https://github.com/allenai/tango), `colt` aims to offer similar functionality while focusing on a more lightweight and user-friendly design.



  While both AllenNLP and Tango construct objects based on the class signature, colt focuses on building objects from the type specified in the configuration. Although colt is aware of the class signature, it primarily uses it for validation when passing objects created from the configuration.

  This means that with colt, you don't necessarily need to have the target class available for configuration. As a result, you can conveniently build objects using the colt.build method without requiring the specific class to be present. This distinction makes colt more flexible and easier to work with in various scenarios.



  To install colt, simply run the following command:

  ```shell
  pip install colt
  ```





  Here is a basic example of how to use `colt` to create class objects from a configuration dictionary:

  ```python
  import typing as tp
  import colt

  @colt.register("foo")
  class Foo:
      def __init__(self, message: str) -> None:
          self.message = message

  @colt.register("bar")
  class Bar:
      def __init__(self, foos: tp.List[Foo]) -> None:
          self.foos = foos

  if __name__ == "__main__":
      config = {
          "@type": "bar",  # specify type name with `@type`
          "foos": [
              {"message": "hello"},  # type of this is inferred from type-hint
              {"message": "world"},
          ]
      }

      bar = colt.build(config)

      assert isinstance(bar, Bar)

      print(" ".join(foo.message for foo in bar.foos))
          
  ```





  You can guide the object construction process in `colt` by passing the desired class as the second argument to the `colt.build` method.
  Here's an example demonstrating this functionality:

  ```python
  @colt.register("foo")
  class Foo:
      def __init__(self, x: str) -> None:
          self.x = x

  config = {"x": "abc"}


  obj = colt.build(config, Foo)

  assert isinstance(obj, Foo)
  assert obj.x == "abc"
  ```

  By providing the target class to `colt.build`, you can ensure the constructed object is of the desired type while still using the configuration for parameter values.



  `colt` provides the Registrable class, which allows you to divide the namespace for each class.
  This can be particularly useful when working with larger projects or when you need to manage multiple classes with the same name but different functionality.

  Here is an example of how to use the `Registrable` class to manage different namespaces for `Foo` and `Bar`:

  ```python
  import colt

  class Foo(colt.Registrable):
      pass

  class Bar(colt.Registrable):
      pass

  @Foo.register("baz")
  class FooBaz(Foo):
      pass

  @Bar.register("baz")
  class BarBaz(Bar):
      pass

  @colt.register("my_class")
  class MyClass:
      def __init__(self, foo: Foo, bar: Bar):
          self.foo = foo
          self.bar = bar

  if __name__ == "__main__":
      config = {
          "@type": "my_class",
          "foo": {"@type": "baz"},
          "bar": {"@type": "baz"}
      }

      obj = colt.build(config)

      assert isinstance(obj.foo, FooBaz)
      assert isinstance(obj.bar, BarBaz)
  ```



  `colt` offers a `Lazy` class for deferring object creation until needed, which can be useful in cases where constructing an object is computationally expensive or should be delayed until certain conditions are met.

  Here's a concise example demonstrating the `Lazy` class usage with `colt`:

  ```python
  import dataclasses
  import colt
  from colt import Lazy

  @dataclasses.dataclass
  class Foo:
      x: str
      y: int

  @dataclasses.dataclass
  class Bar:
      foo: Lazy[Foo]

  bar = colt.build({"foo": {"x": "hello"}}, Bar)


  foo = bar.foo.construct(y=10)
  ```

  In this example, `Bar` contains a `Lazy` instance of `Foo`, which will only be constructed when `construct()` is called.
  When calling `construct()`, you can pass additional parameters required for the object's construction.
  This approach allows you to control when an object is created, optimizing resource usage and computations while providing flexibility in passing parameters.





  Here's an example of how to use `colt` to configure a [scikit-learn](https://scikit-learn.org/) model:

  ```python
  import colt

  from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split

  if __name__ == "__main__":
      config = {
          
          "@type": "sklearn.ensemble.VotingClassifier",
          "estimators": [
              ("rfc", { "@type": "sklearn.ensemble.RandomForestClassifier",
                        "n_estimators": 10 }),
              ("svc", { "@type": "sklearn.svm.SVC",
                        "gamma": "scale" }),
          ]
      }

      X, y = load_iris(return_X_y=True)
      X_train, X_valid, y_train, y_valid = train_test_split(X, y)

      model = colt.build(config)
      model.fit(X_train, y_train)

      valid_accuracy = model.score(X_valid, y_valid)
      print(f"valid_accuracy: {valid_accuracy}")
  ```

  In this example, `colt` is used to configure a `VotingClassifier` from scikit-learn, combining a `RandomForestClassifier` and an `SVC`.
  The colt configuration dictionary makes it easy to manage the settings of these classifiers and modify them as needed.



  `colt` is heavily influenced by the following projects:

  - [AllenNLP](https://github.com/allenai/allennlp): A popular natural language processing library, which provides a powerful configuration system for managing complex experiments.
  - [Tango](https://github.com/allenai/tango): A lightweight and flexible library for running machine learning experiments, designed to work well with AllenNLP and other libraries.

  These projects have demonstrated the value of a robust configuration system for managing machine learning experiments and inspired the design of `colt`.


pkgId: d0778aa0fcfd7bfb9fc146ec77e613152e27062c2a3f633648eed48b4d6c52b1
name: python-coltrane
arch: src
version: 0.37.0
epoch: 0
release: 1
summary: A minimal app framework for content sites 🎵
url: https://github.com/adamghill/coltrane
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coltrane-0.37.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://coltrane.readthedocs.io"><h1 align="center">coltrane</h1></a>
  </p>
  <p align="center">A minimal app framework for content sites 🎵</p>

  ![PyPI](https://img.shields.io/pypi/v/coltrane?color=blue&style=flat-square)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/coltrane?color=blue&style=flat-square)
  ![GitHub Sponsors](https://img.shields.io/github/sponsors/adamghill?color=blue&style=flat-square)
  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  ![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  📖 Complete documentation at https://coltrane.readthedocs.io.

  📦 Package located at https://pypi.org/project/coltrane/.



  - Render `markdown` files as HTML with automatic URL routing based on the filesystem
  - Use JSON files as data sources in HTML templates or `markdown`
  - Automatic generation of `sitemap.xml` and `rss.xml` files
  - Can serve non-markdown files like `robots.txt`
  - Local development server which includes [live re-rendering of markdown and data](https://twitter.com/adamghill/status/1487522925393715205) via https://github.com/adamchainz/django-browser-reload
  - Site-wide redirects
  - Deployment best practices with `whitenoise` and `gunicorn` already configured
  - Leverage the power of built-in `Django` templates, template tags, and filters inside `markdown` files
  - Any custom template tags and filters are enabled automatically for use in `markdown` or HTML templates
  - Include any third-party [`Django` app](https://djangopackages.org) for additional functionality
  - Optional command to generate static HTML files
  - Can be integrated into a regular `Django` project as a standard third-party `Django` app to render markdown content



  1. `mkdir new-site && cd new-site` to create a new folder
  1. `python3 -m venv .venv && source .venv/bin/activate && pip install coltrane` to install the `coltrane` package
  1. `coltrane create` to create the folder structure for a new site
  1. `coltrane play` to start local development server
  1. Go to http://localhost:8000 to see the original markdown rendered into HTML
  1. Update `content/index.md`
  1. Refresh http://localhost:8000 to see the updated markdown rendered into HTML
  1. Optional: run `coltrane record` to build static HTML files



  ```bash
  .
  ├── .gitignore
  ├── Dockerfile
  ├── README.md
  ├── pyproject.toml
  └── site
      ├── .env
      ├── .watchmanconfig
      ├── __init__.py
      ├── app.py
      ├── content
      │   └── index.md
      ├── data
      ├── gunicorn.conf.py
      ├── static
      └── templates
  ```



  Add `markdown` files or sub-directories to the `content` directory and rendered HTML will be accessible via auto-generated routes.

  - `/` would render the `markdown` in `content/index.md`
  - `/about/` would render the `markdown` in `content/about.md`
  - `/articles/this-is-the-first-article/` would render the content from `/content/articles/this-is-the-first-article.md`
  - `/not-there/` will 404

  HTML will also be served automatically if a `markdown` file can not be found.

  - `/app/` would render the HTML from `/templates/app.html` or `/templates/app/index.html`
  - `/app/some-user` would render the HTML from `/templates/app/*.html`



  Example `Dockerfile` and `gunicorn.conf.py` files are created when an app is created, and optional dependencies can be installed for efficient `static` serving with `whitenoise`.



  Read all of the documentation at https://coltrane.readthedocs.io.



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center"><a href="https://github.com/Tobi-De"><img src="https://avatars.githubusercontent.com/u/40334729?v=4?s=100" width="100px;" alt="Tobi DEGNON"/><br /><sub><b>Tobi DEGNON</b></sub></a><br /><a href="https://github.com/adamghill/coltrane/commits?author=Tobi-De" title="Tests">⚠️</a> <a href="https://github.com/adamghill/coltrane/commits?author=Tobi-De" title="Code">💻</a></td>
      </tr>
    </tbody>
    <tfoot>

    </tfoot>
  </table>

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

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

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

rpm_license:
  MIT License  Copyright (c) 2022 Adam Hill  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: ad317d6f1147b620836dbd8eccb611b68a0287d0271ec1d8dc23f2c98b78f695
name: python-coltrane-web
arch: src
version: 0.18.4
epoch: 0
release: 1
summary: A simple content site framework that harnesses the power of Django without the hassle.
url: https://github.com/adamghill/coltrane/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coltrane-web-0.18.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://coltrane.readthedocs.io"><h1 align="center">coltrane</h1></a>
  </p>
  <p align="center">A simple content site framework that harnesses the power of Django without the hassle 🎵</p>

  `coltrane-web` has been renamed to [coltrane](https://pypi.org/project/coltrane/).


pkgId: 4fabd704a14655cb8c3563d88ac39598e5081143c7d72ec34ca197f43133dcfc
name: python-columnar
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: A tool for printing data in a columnar format.
url: https://pypi.org/project/columnar/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-columnar-1.4.1-1.src.rpm
checksum_type: sha256
description:
  A library for creating columnar output strings using data as input.


  ```
  pip install columnar
  ```


  ```python
  from columnar import columnar
  from click import style

  data = [
      ['Strade Bianche', 'Saturday 9th March', 'Tuscany, Italy', "Men's - 176km / Women's - 103km. Both men's and women's "],
      ['Omloop Het Nieuwsblad', 'Saturday 2nd March', 'Gent, Belgium', "Men's - 200km / Women's - 130km"],
      ['Milan-San Remo', 'Saturday 23rd March', 'Milan to San Remo, Italy', '295km'],
      ['Tour of Flanders', 'Sunday 7th April', 'Antwerp to Oudenaarde, Flanders region, Belgium', '260km']
  ]

  patterns = [
      ('Saturday.+', lambda text: style(text, fg='white', bg='blue')),
      ('\d+km', lambda text: style(text, fg='cyan')),
      ('Omloop Het Nieuwsblad', lambda text: style(text, fg='green')),
      ('Strade Bianche', lambda text: style(text, fg='white')),
      ('Milan-San Remo', lambda text: style(text, fg='red')),
      ('Tour of Flanders', lambda text: style(text, fg='yellow')),
  ]

  table = columnar(data, headers=['Race', 'Date', 'Location', 'Distance'], patterns=patterns)
  print(table)
  ```
  ![Table Displaying Spring Classics](https://github.com/MaxTaggart/columnar/raw/master/columnar/images/example_spring_classics.png)

  Or for that fresh Docker look:

  ```python
  from columnar import columnar

  headers = ['name', 'id', 'host', 'notes']

  data = [
      ['busybox', 'c3c37d5d-38d2-409f-8d02-600fd9d51239', 'linuxnode-1-292735', 'Test server.'],
      ['alpine-python', '6bb77855-0fda-45a9-b553-e19e1a795f1e', 'linuxnode-2-249253', 'The one that runs python.'],
      ['redis', 'afb648ba-ac97-4fb2-8953-9a5b5f39663e', 'linuxnode-3-3416918', 'For queues and stuff.'],
      ['app-server', 'b866cd0f-bf80-40c7-84e3-c40891ec68f9', 'linuxnode-4-295918', 'A popular destination.'],
      ['nginx', '76fea0f0-aa53-4911-b7e4-fae28c2e469b', 'linuxnode-5-292735', 'Traffic Cop'],
  ]

  table = columnar(data, headers, no_borders=True)
  print(table)
  ```

  ![Table Displaying No-border Style](https://github.com/MaxTaggart/columnar/raw/master/columnar/images/example_no_borders.png)

  > Note that when using the `no_borders` argument the headers will be capitalized by default. This can be disabled by passing `preformatted_headers=True`.

  Columnar also supports emojis and characters that take up two display columns (assuming your display knows what to do with them):

  ``` python
  from columnar import columnar

  headers = ["User", "Message", "Zip"]
  data = [
      ['Yiying Lu', 'Fried Dumplings!!!! Yum! 😍😍😍', 47130],
      ['Jennifer Lee', 'Facebook banned the 🍑, can you believe it?', 97153],
      ['Premier12', '本日のヒーロー🦸周東選手✨　#周東佑京　#侍ジャパン #プレミア12 #AUSP12 #Premier12', 549726]
  ]
  table = columnar(data, headers)
  print(table)
  ```

  ![Table with Emojis and Wide Characters](https://github.com/MaxTaggart/columnar/raw/master/columnar/images/emojis_and_wide_chars.png)


  Columnar supports patterns, which are two-item tuples each containing a regular expression and a function. The regular expression is applied to each item in `data` using `re.match()` and if there is a match the corresponding function is applied to the text of that element. Only the first matching pattern is applied, meaning patterns can be prioritized by their order in the input array. This can be used to perform colorization, casing, or other custom tasks that will affect the display of the text in the table.



  As noted above, color may be applied to text by adding it to the text through a pattern. However, text may also be pre-colored by applying ANSI color codes to the text before it is passed to `columnar` as made easy by libraries like `click` and `colorama`. Note however, that any color that is applied will be applied to the contents of the whole cell. For example, if the text for a cell is
  ```python
  f"unmodified text {click.style('modified text', fg='blue')} more unmodified text"
  ```
  the entire cell's text will be turned blue.



  If your table has a large number of columns, or you wish to highlight a subset of the columns use the `select` keyword argument. It takes a list of strings which are compiled to regular expressions using `re.compile(arg, re.I)` and used to select columns using `pattern.search(column_name)`. For example, given the following columns

  ```
  ['Name', 'BirthDate', 'Zip Code', 'City Code', 'County Code']
  ```

  using `select=['name', '.*code']` will select all columns except the `BirthDate` column.


  It is often the case that one or more columns of the data will not be useful. For example, columns where all the values are "Null" or "-". To filter out these columns use the `drop` keyword argument. This argument takes a list of values and drops any column whose contents are a subset of those values. For example, given four columns

  ```
  a   NA  1   -
  b   NA  2   Null
  -   NA  3   -
  d   NA  4   None
  ```

  using `drop=['-', 'Null', 'NA', 'None']` will drop the second and fourth columns, even though the first column contains a dash also.



  There are an infinite number of ways to determine column sizing and text wrapping given a dataset. This package allows the user to specify a minimum column width, a maximum column width, and a "wrap max" which partially define wrapping and column sizing. The rest of the logic that goes into determining how to fit data into a table when the data is wider than the terminal employs a pretty simple heuristic. First determine how wide each column wants to be without wrapping. If all the columns are too wide to fit on the screen, shrink as many columns as are needed in order for the table to fit, starting with the widest column and progressing through the columns from largest to smallest. If the size of the columns falls below the minimum column width then raise an exception, specifically a `columnar.exceptions.TableOverflowError`. This should only happen if there are so many columns that `terminal_width / num_columns` is less than the minimum column width.



  The contents of a column are wrapped as needed to fit in the column with no effort made to split on spaces. However, new-line characters are preserved and tab characters are replaced with four spaces. The maximum number of times the contents of a column are wrapped before being truncated is given by `wrap_max`. Another way to think about `wrap_max` is that `wrap_max + 1` is the maximum number of rows a single cell can occupy. Any content past the `wrap_max + 1`th row is truncated.







  An iterable of iterables, typically a list of lists of strings where each string will occupy its own cell in the table. However, list elements need not be strings. No matter what is passed, each element in the list is converted to a string using `str()`.
  ***


  A list of strings, one for each column in `data`, which will be displayed as the table headers. If left as `None` this will produce a table that does not have a header row.
  ***


  As explained above, patterns accepts a list of two-item tuples which can be used to transform the input `data` in order to perform tasks like text coloring, capitalization, or other formatting.
  ***


  As explained above, drop takes a list of strings and if any column contains only elements in that list the column and its corresponding header will be excluded from the table. Can be used to exclude columns where all the values are "Null", or "-", etc. If an empty list is passed (default) then no columns are dropped.
  ***


  Accepts a list of string that are compiled to regular expressions using the case insensitive, `re.I`, flag. Any column that matches any of these regular expressions is kept while all other columns are dropped. If `select` is specified `drop` is ignored, meaning that it is possible to display columns that may have been dropped by `drop` by specifying them in `select`. Passing an empty list (default) causes all columns not dropped by `drop` to be displayed.
  ***


  Accepts a boolean value that specifies whether or not to display the borders between rows and columns. Passing `True` will hide all the borders and convert the headers to all caps for a more minimalistic look.
  ***


  Similar to the unix bash command, displays only `head` number of rows of data. For example
  ```python
  columnar(data, headers, head=4)
  ```
  will display the first four rows of data. Passing `0` (default) will display all the data.
  ***


  Specifies how each column should be justified. Justification options are either `l`, `c`, or `r` for left, center, and right justification respectively.

  This argument accepts either a single value, or a list with `len(list) == num_columns`. If a single value is specified the justification for all columns will be set to that value. Otherwise, if a list is supplied, values will be applied to each column individually. For exmaple
  ```python
  columnar(data, headers=['one', 'two', 'three'], justify='c')
  ```
  will center all three columns, while
  ```python
  columnar(data, headers=['one', 'two', 'three'], justify=['r', 'c', 'l'])
  ```
  will right-justify column 'one', center column 'two', and left-justify column 'three'.
  ***


  Sets the maximum number of times a line will wrap inside its cell. Another way to think of this is that `wrap_max + 1` is the maximum number of lines that a cell can occupy. New-line characters in the input are preserved, meaning that they count against the value of `wrap_max`.
  ***


  Sets the maximum width for a column, causing the contents to wrap if they contain more characters than `max_column_width`. Setting this value to `None` (default) will only cause text to be wrapped if the whole table is too wide to fit on the screen causing the column-sizing algorithm to kick in.
  ***


  Sets the minimum width of a column, adding whitespace to either the left side, right side, or both sides depending on the value of `justify`. Note that if `min_column_width` is too high the table may not fit on the screen and a `columnar.exceptions.TableOverflowError` will be thrown.
  ***


  Specifies the character, or string, used to draw borders between the rows.
  ***


  Specifies the character, or string, used to draw borders between the columns.
  ***


  Specifies the width of the output display. If left as `None` the width will default to `shutil.get_terminal_size().columns`. However, for cases where the default does not give a desirable result the display width can be specified here.
  ***


  Controls header formatting when `no_borders==True`. The default, `False`, will cause the headers to be automatically capitalized. `True` will use the headers as provided without any modification.


pkgId: 12de4b3e8a0485bcab505fa4386c2bb3794ef3f6795778c2a7a6a416d0636485
name: python-columnarframe
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/tamuto/columnarframe
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-columnarframe-0.7.0-1.src.rpm
checksum_type: sha256
description:
  カラムベースでデータを扱うためのライブラリです。
  ある程度Pandasのように操作できるような形を目指しています。

  This is a library for handling column-based data.
  It is intended to be operated like Pandas to some extent.



  * unittest

  ```
  poetry run python -m unittest discover
  ```

  * build

  ```
  poetry build
  ```

  * publish(Test)

  ```
  poetry publish -r testpypi
  ```

  * public(real)

  ```
  poetry publish
  ```

  * lib install

  ```
  poetry add xxxx
  ```


pkgId: a3e9446fda47baa507c370d3b50050bed5b242613191ac4d5d88d5d327cb5c29
name: python-com-digitalruiz-shopify-tools
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: Collections of custom shopify functions
url: https://github.com/reyesruiz/shopify_tools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-com-digitalruiz-shopify-tools-0.0.16-1.src.rpm
checksum_type: sha256
description:
  Collection of custom shopify functions

  Config file needed at ~/.Shopify-Config.json which will be used by com_digitalruiz_shopify_http_client
  ```
  {
    "shopify_store_name": "YOUR-STORE-NAME",
    "shopify_admin_api_version": "API VERSION",
    "shopify_access_token": "ACCESS TOKEN"
  }
  ```
  example use:

  ```
  from com_digitalruiz_shopify_tools import shopify_tools

  ```


pkgId: b5a1f383a974f7f1a1a9aa571494a333d69747cc78215d3045db46f1970294d9
name: python-com-enovation
arch: src
version: 0.0.40
epoch: 0
release: 1
summary: project management toolbox
url: https://jsebastien_Guillard@bitbucket.org/jsebastien_Guillard
rpm_license: Other/Proprietary License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-com-enovation-0.0.40-1.src.rpm
checksum_type: sha256
description:
  Our python tool-box is supposed to help professionals in their day-to-day work.
  Everything started when reaching blocking limitations with MS Excel, forcing us to search for alternatives. We learned Python, and started to implement reusable snippets.
  As of 2021, we have a first workable snippet (yet perfectible), and we target to progressively (even-though
  slowly) enrich this tool-box, focusing on "IT project management" related stuff (as a start?).


pkgId: 5791fb9822e21dd3c0d2847918876d31b730e2e1dea68dab9bdeccbd40641f46
name: python-com-server
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A simple Python library and a REST API server that interacts with COM ports
url: https://github.com/jonyboi396825/COM-Server
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-com-server-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/jonyboi396825/COM-Server/Run%20Pytest%20(Push%20to%20master))
  [![Documentation Status](https://readthedocs.org/projects/com-server/badge/?version=latest)](https://com-server.readthedocs.io/en/latest/?badge=latest)
  ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/jonyboi396825/COM-Server/Upload%20Python%20Package?label=PyPI%20upload)
  ![PyPI](https://img.shields.io/pypi/v/com_server?label=Version)

  COM-Server is a Python library and a local web server that hosts an API locally and interacts with serial or COM ports. The Python library provides a different way of sending and receiving data from the serial port using a thread, and it also gives a set of tools that simplifies the task of manipulating data to and from the port. Additionally, the server makes it easier for other processes to communicate with the serial port.

  The serial communication uses [pyserial](https://pyserial.readthedocs.io/en/latest/pyserial.html) as its back-end and the server uses [flask-restful](https://flask-restful.readthedocs.io/en/latest/quickstart.html) and [Flask](https://flask.palletsprojects.com/en/2.0.x/). Reading their documentations may help with developing with COM-Server.

  **NOTE**: COM-Server has only been tested on:
  Operating systems:

  - Ubuntu 20.04 (Focal Fossa)
  - Raspberry Pi OS 10 (Buster)
  - Mac OS 10.15.x (Catalina)
  - Mac OS 11.6 (Big Sur)
  - Windows 10

  Python versions:

  - Python 3.7.2
  - Python 3.7.3
  - Python 3.8.10
  - Python 3.9.7
  - Python 3.10.0

  Serial ports:

  - Arduino UNO
  - Arduino Nano


  COM-Server is **not** meant to be used like a normal JSON API, even though it uses Flask and Flask-restful. If there are many different devices accessing the endpoints at the same time, data will be backed up, since the serial communication is relatively slow and things cannot be sent to the serial device at the same time.

  The server is recommended to be used like a socket, and it should be used as a way for another process (should be only one; COM-Server has no implemented synchronization) on one computer (could be the same computer or another one on the same network) to communicate with the serial port via `pyserial` and this Python program.




  **NOTE**: COM-Server only works on Python >= 3.6.

  Using [pip](https://pip.pypa.io/en/stable/getting-started/):
  ```sh
  > pip install -U com-server
  ```

  For beta releases, use the `--pre` option:
  ```sh
  > pip install --pre com-server
  ```



  ```py


  import com_server

  conn = com_server.Connection(<baud>, "<serport>")
  handler = com_server.RestApiHandler(conn)
  com_server.Builtins(handler)

  handler.run_dev(host="0.0.0.0", port=8080)

  conn.disconnect()
  ```
  Replace "&lt;serport&gt;" and "&lt;baud&gt;" with the serial port and baud rate.

  Alternatively, you can use the command line:
  ```sh
  > com_server run <baud> <serport>
  ```
  Again, replace "&lt;serport&gt;" and "&lt;baud&gt;" with the serial port and baud rate.


  - Documentation: [https://com-server.readthedocs.io/en/latest/](https://com-server.readthedocs.io/en/latest/)
  - Source code: https://github.com/jonyboi396825/COM-Server
  - Issue tracker: https://github.com/jonyboi396825/COM-Server/issues
  - Contributing: [https://github.com/jonyboi396825/COM-Server/blob/master/CONTRIBUTING.md](https://github.com/jonyboi396825/COM-Server/blob/master/CONTRIBUTING.md)
  - Changelog: [https://github.com/jonyboi396825/COM-Server/blob/master/CHANGELOG.md](https://github.com/jonyboi396825/COM-Server/blob/master/CHANGELOG.md)


pkgId: c55ce9103f953fb007e2922c90561d324b99fa7fb0653fa32960200faf28aea4
name: python-com.castsoftware.uc.arg
arch: src
version: 1.7.5
epoch: 0
release: 1
summary: Assessment Report Generator (ARG)
url: https://github.com/CAST-Extend/com.castsoftware.uc.arg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-com.castsoftware.uc.arg-1.7.5-1.src.rpm
checksum_type: sha256
description:
  ARG (Assessment Report Generator) produces a PowerPoint presentation comprising one or several applications and multiple spreadsheets holding corroborating data, all originating from either the highlight or cast REST APIs. This version offers two distinct templates - one solely designed for Highlight and the other specifically catered towards AIP and Highlight decks.

  * Save time by quickly generating professional PowerPoint decks with ease
  * Combine two powerful APIs for comprehensive and accurate assessments
  * Streamline the process and increase efficiency for assessment report creation

  Download the latest release from [CAST Extend](https://extend.castsoftware.com/#/extension?id=com.castsoftware.uc.arg&version=latest) today.

  At Cast Software, we strive to provide our clients with the best possible experience. However, we understand that issues may arise from time to time. That's why we encourage you to reach out to us at oneclick@castsoftware.com for any concerns or problems you may encounter. Our team of dedicated professionals is ready to assist you and ensure that your experience with our software is seamless and satisfactory. Your feedback is valuable to us and we appreciate the opportunity to address any issues you may have. Thank you for choosing Cast Software.


pkgId: c16e192c3f18f5fa8af997e4e67098b2160729f715d706dbb4d7f4ef782ab7f6
name: python-com.precisely.apis
arch: src
version: 18.1.1
epoch: 0
release: 1
summary: Precisely APIs
url: https://developer.precisely.com/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-com.precisely.apis-18.1.1-1.src.rpm
checksum_type: sha256
description:
      Enhance and enrich your data, applications, business processes, and workflows with rich location, information, and identify APIs.


pkgId: 46ce354c2efb8a652a65a214330d71f3bb252b2dd1f4dabec2e1fce345c00e56
name: python-com2ann
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Tool to translate type comments to annotations.
url: https://github.com/ilevkivskyi/com2ann
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-com2ann-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Tool for translation of type comments to type annotations in Python.
  This tool requires Python 3.8 to run. But the supported target code version
  is Python 3.4+ (can be specified with ``--python-minor-version``).
  Currently, the tool translates function and assignment type comments to
  type annotations.
  The philosophy of of the tool is too minimally invasive, and preserve original
  formatting as much as possible. This is why the tool doesn't use un-parse.


pkgId: 4727c96b53a1ff2334475517717c2ed287893609daee2484ebe7725a054886f9
name: python-comap
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Allows easy automation of WebSupervisor tasks, such as downloading and analyzing data
url: https://github.com/bruxy70/ComAp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comap-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Use `ComAp-Key`, `client_id` and `secret` to obtain the ``Bearer Token``, that is needed to authenticate to the WSV API.
  *Example:*
  ```python
  from comap import api
  CLIENT_ID = ... # get the id from the a repository
  SECRET = ...    # get the secret from a key repository
  COMAP_KEY = ... # get the key from a key repository

  identity = api.Identity(COMAP_KEY)
  token = identity.authenticate(CLIENT_ID, SECRET)
  ```
  *Returns*
  ```yaml
  {
      'token_type': 'Bearer',
      'expires_in': 3599,
      'ext_expires_in': 3599,
      'access_token': 'eyJ0e***redacted***1Z_roeA'
  }
  ```
  Get the `ComAp-Key` in your [Profile](https://portal.websupervisor.net/developer), the other two values will be available on the Customer portal.
  Until then, you can generate them from the API documentation using the "Try it" feature:
  1. [Create Application Registration](https://portal.websupervisor.net/docs/services/comap-cloud-identity/operations/application-create?) - this will return the `client_id`.
  2. [Create Application Secret](https://portal.websupervisor.net/docs/services/comap-cloud-identity/operations/application-secret-create?) - this will return the secret
  These values are valid for 2 years. If you need new values, [Delete Application Registration](https://portal.websupervisor.net/docs/services/comap-cloud-identity/operations/application-delete?) and create new ones.

  Authenticate and return bearer token dictionary.
  | Parameter | Type | Value |
  | --- | --- | --- |
  | client_id | `str` | From ComAp customer portal<br />Or generated on API Documentation test portal using Create application registration API
  | secret | `str` | From ComAp customer portal<br />Or generated on API Documentation test portal using Create application secret API
  **Returns**
  The bearer access token `dict` or `None` if failed.
  ```
  {
      'token_type': `str`,
      'expires_in': `number`,
      'ext_expires_in': `number`,
      'access_token': `str` # this is the Bearer access token
  }


pkgId: aff55ec2b2c7224037057374a045d7c49e5de4eec8ae0767906a4e01f2b894fc
name: python-comb-spec-searcher
arch: src
version: 4.2.0
epoch: 0
release: 1
summary: A library for performing combinatorial exploration.
url: https://github.com/PermutaTriangle/comb_spec_searcher
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comb-spec-searcher-4.2.0-1.src.rpm
checksum_type: sha256
description:
  The ``comb_spec_searcher`` package contains code for combinatorial
  exploration.
  If this code is useful to you in your work, please consider citing it. To generate a
  BibTeX entry (or another format), click the "DOI" badge above and locate the "Cite As"
  section.


pkgId: 02e8776af75d306ad4a79078817a85b35aca1b3ad25e91ecd0bb705fc44fad82
name: python-combadge
arch: src
version: 4.5.0
epoch: 0
release: 1
summary: Generic API client based on Pydantic
url: https://github.com/kpn/combadge
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combadge-4.5.0-1.src.rpm
checksum_type: sha256
description:
  Combadge generates a service client implementation from a user service interface
  declared by a [protocol](https://peps.python.org/pep-0544/) class or an abstract base class.

  [![Checks](https://img.shields.io/github/checks-status/kpn/combadge/main?logo=github)](https://github.com/kpn/combadge/actions/workflows/check.yaml)
  [![Coverage](https://codecov.io/gh/kpn/combadge/branch/main/graph/badge.svg?token=ZAqYAaTXwE)](https://codecov.io/gh/kpn/combadge)
  ![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)
  [![Python Version](https://img.shields.io/pypi/pyversions/combadge?logo=python&logoColor=yellow)](https://pypi.org/project/combadge/)
  [![License](https://img.shields.io/github/license/kpn/combadge)](LICENSE)



  <a href="https://kpn.github.io/combadge/">
      <img alt="Documentation" height="30em" src="https://img.shields.io/github/actions/workflow/status/kpn/combadge/docs.yml?label=documentation&logo=github">
  </a>



  ```python title="quickstart_httpx.py"
  from httpx import Client
  from pydantic import BaseModel, Field
  from typing_extensions import Annotated, Protocol

  from combadge.support.http.markers import QueryParam, http_method, path
  from combadge.support.httpx.backends.sync import HttpxBackend



  class CurrentCondition(BaseModel):
      humidity: int
      temperature: Annotated[float, Field(alias="temp_C")]


  class Weather(BaseModel):
      current: Annotated[list[CurrentCondition], Field(alias="current_condition")]



  class SupportsWttrIn(Protocol):
      @http_method("GET")
      @path("/{in_}")
      def get_weather(
          self,
          *,
          in_: str,
          format_: Annotated[str, QueryParam("format")] = "j1",
      ) -> Weather:
          raise NotImplementedError



  with HttpxBackend(Client(base_url="https://wttr.in"))[SupportsWttrIn] as service:
      
      response = service.get_weather(in_="amsterdam")

  assert response.current[0].humidity == 71
  assert response.current[0].temperature == 8.0
  ```


pkgId: 8483121efdf3cd42af72d9aee62fcb084fb85e0a4f70c59c62392f87291a2af9
name: python-combat
arch: src
version: 0.3.3
epoch: 0
release: 1
url: https://github.com/epigenelabs/pyComBat
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combat-0.3.3-1.src.rpm
checksum_type: sha256
summary:
  pyComBat, a Python tool for batch effects correction in high-throughput molecular data using empirical Bayes methods

description:
  pyComBat [1] is a Python 3 implementation of ComBat [2], one of the most widely used tool for correcting technical biases, called batch effects, in microarray expression data.

  More detailed documentation can be found at [this address](https://epigenelabs.github.io/pyComBat/).





  We list here the versions of the packages that have been used for development/testing of pyComBat, as well as for writing the documentation.



  * python 3.6

  * numpy 1.18.5

  * mpmath 1.1.0

  * pandas 0.24.2

  * patsy 0.5.1



  * sphinx 2.1.2





  You can install pyComBat directly with:

  ```python
  pip install combat
  ```

  You can upgrade pyComBat to its latest version with:

  ```python
  pip install combat --upgrade
  ```



  The simplest way of using pyComBat is to first import it, and then simply use the pycombat function with default parameters:

  ```python
  from combat.pycombat import pycombat
  data_corrected = pycombat(data,batch)
  ```

  * data: The expression matrix as a dataframe. It contains the information about the gene expression (rows) for each sample (columns).

  * batch: List of batch indexes. The batch list describes the batch for each sample. The list of batches contains as many elements as the number of columns in the expression matrix.



  Please refer to [CONTRIBUTING.md](https://github.com/epigenelabs/pyComBat/blob/master/CONTRIBUTING.md) to learn more about the contribution guidelines.



  [1] Behdenna A, Haziza J, Azencot CA and Nordor A. (2020) pyComBat, a Python tool for batch effects correction in high-throughput molecular data using empirical Bayes methods. bioRxiv doi: 10.1101/2020.03.17.995431

  [2] Johnson W E, et al. (2007) Adjusting batch effects in microarray expression data using empirical Bayes methods. Biostatistics, 8, 118–127


pkgId: 0d6e4a9942dfe9b11429bf9908b24a06bed6704fde69828e3d7a7e4dfe5e6746
name: python-combidata
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: Package for random data generation and combination different cases
url: https://warrfie.github.io/combidata
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combidata-0.2.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Package Version](https://img.shields.io/pypi/v/combidata.svg)](https://pypi.python.org/pypi/combidata)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/combidata.svg)](https://pypi.python.org/pypi/combidata)
  [![PyPi status](https://img.shields.io/pypi/status/combidata.svg?style=flat-square)](https://pypi.python.org/pypi/combidata)


  <p align="center">
    <img src="docs/assets/logo.svg" alt="Combidata Logo" width="200" height="200"/>
  </p>
  Combidata is a case-oriented library designed for compositional testing of combinatorics in IT product functionalities.




  ```
  pip install combidata
  ```



  - [Installation](https://warrfie.github.io/combidata/Installation)
  - [All entities](https://warrfie.github.io/combidata/Cases)
    - [Process](https://warrfie.github.io/combidata/Process)
    - [Cases](https://warrfie.github.io/combidata/Cases)
    - [Combination](https://warrfie.github.io/combidata/Combination)
    - [DataGenerator](https://warrfie.github.io/combidata/DataGenerator)
  - [Quick Start Guide](https://warrfie.github.io/combidata/QSG)



  Combidata provides a comprehensive solution for compositional testing, allowing users to efficiently test various combinations of functionalities in IT products. With its unique approach to case-oriented testing, Combidata streamlines the testing process, ensuring robust and reliable results.



  - **Case-Oriented Testing**: Focus on specific test cases to ensure thorough testing of functionalities.
  - **Compositional Testing**: Test combinations of functionalities to ensure interoperability and compatibility.
  - **Efficient Workflow**: Streamlined processes for test generation, execution, and reporting.
  - **Extensive Documentation**: Comprehensive guides and tutorials to help you get started and make the most of Combidata.



  To get started with Combidata, visit our [Quick Start Guide](https://warrfie.github.io/combidata/QSG) which provides step-by-step instructions on setting up and using the library.


  If you need help with Combidata or have any questions, please open an issue on GitHub or contact the maintainers directly

  Telegram вЂ” https://t.me/sasisochka

  Linkedin вЂ” https://www.linkedin.com/in/yasasisochka/



  Combidata is licensed under [MIT License](LICENSE).


pkgId: ad8fd014185e5c9e79c7189ff810d99ffd2275b931400255e99f4f551662c70c
name: python-combilog-handler
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: Interfaces with inbuilt python logger to send logs to combilog aggregator.
url: https://github.com/lewjc/combilog-pythonhandler
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combilog-handler-1.0.16-1.src.rpm
checksum_type: sha256
description:
  Python package containing custom log handler to integrate with CombiLog



  ```
  $ pip install combilog-handler
  ```



  Example usage

  ```
  import logging
  import combilog_handler


  url = "ws://AGG_DOMAIN:AGG_SOCKET_PORT"


  secret = "MY-SPECIAL-SECRET"

  logger = logging.Logger("NamedService")
  handler = combilog_handler.loghandler.CombilogHandler(aggregator_url=url, service_secret=secret)
  formatter = logging.Formatter("s - s - s - s")
  handler.setFormatter(formatter)
  logger.addHandler(handler)

  ```


pkgId: 30782dcf0e775f68084ea8e346b731ac0450c5d25ee42c2a5513684ef967f45b
name: python-combinatorial-peptide-pooling
arch: src
version: 0.0.31
epoch: 0
release: 1
summary: TCR deorphanization using combinatorial pooling strategy
url: https://github.com/meyer-lab-cshl/combinatorial_pooling
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combinatorial-peptide-pooling-0.0.31-1.src.rpm
checksum_type: sha256
description:
  You can install the package with pip:

  `pip install combinatorial_peptide_pooling`

  Or with conda:

  `conda install -c vasilisa.kovaleva combinatorial_peptide_pooling`



  `import combinatorial_peptide_pooling as cpp`

  To use the package for basic tasks, the **Quickstart** section is enough. To read more about used functions, check other sections.



  1. *[optional] Check your peptide list for overlap consistency.

      Uncosistent overlap length can lead to hindered results interpretation.

      You can check all peptides for their overlap length with the next peptide (list of peptides should be ordered):

      `cpp.all_overlaps(lst)`

      Parameters:

      lst : list, list of peptides (ordered)

      The function returns the Counter object with the dictionary, where the key is the overlap length and the value is the number of pairs with such overlap.

      `cpp.all_overlaps(lst)`

      > `Counter({12: 251, 16: 1})`

      => 251 pairs of peptides with an overlap of length of 12 amino acids, and 1 pair with an overlap of length 16 amino acids.

      Also, you can check which peptides have such an overlap with the next peptide:

      `cpp.find_pair_with_overlap(lst, target_overlap)`

      Parameters:

      lst : list of peptides (ordered)

      target_overlap : int, overlap length

      `cpp.find_pair_with_overlap(lst, 16)`

      > `[['FDEDDSEPVLKGVKLHY', 'DEDDSEPVLKGVKLHYT']]`

      Also, you can check what number of peptides share the same epitope. It might help to interpret the results later.

      `cpp.how_many_peptides(lst, ep_length)`

      Parameters :

      lst : list, list of peptides (ordered)

      ep_length : int, expected epitope length

      The function returns 1) the Counter object with the number of epitopes shared across the number of peptides; 2) the dictionary with all possible epitopes of expected length as keys and the number of peptides where these epitopes are present as values.

      `t,r = how_many_peptides(lst, 8)`

      `t`

      > `Counter({1: 6, 2: 1256, 3: 4})`

      `r`

      > `{'MFVFLVLL': 1,``'FVFLVLLP': 1,``VFLVLLPL': 1,``'FLVLLPLV': 1,``'LVLLPLVS': 1,``'VLLPLVSS': 2, ..., }`

  2. *[optional] Then you need to determine peptide occurrence across pools, i.e. to how many pools one peptide would be added.

      `cpp.find_possible_k_values(n, l)`

      Parameters:

      n : int, number of pools

      l : int, number of peptides

      The function returns a list with possible occurrences given such parameters.

      `cpp.find_possible_k_values(12, 250)`

      > `[4, 5, 6, 7, 8]`

      Choose one occurrence value appropriate for your task and proceed.

  3. Now, you need to find the address arrangement given your number of pools (n_pools), number of peptides (len_list), and peptide occurrence (iters).

      We suggest you use the `address_arrangement_AU` function. In the section “Address arrangement” you can find other functions that can perform such a task (based on Gray codes and based on trivial Hamiltonian path search).

      `b, lines = cpp.address_rearrangement_AU(n_pools, iters, len_lst)`

      Parameters:

      n_pools : int, number of pools

      iters : int, peptide occurrence

      len_lst : int, number of peptides

      With large parameters, the algorithm needs some time to finish the arrangement. If the arrangement fails, try with other parameters.

      The function returns `b` — the expected number of peptides in each pool and `lines` — address arrangement in the list.

      `b, lines = cpp.address_rearrangement_AU(n_pools=12, iters=4, len_lst=250)`

      `b`

      > `[81, 85, 85, 85, 81, 82, 87, 81, 85, 81, 84, 83]`

      `lines`

      > `[[0, 1, 2, 3],``[0, 1, 3, 6],``[0, 1, 6, 8],``[1, 6, 8, 9],``[6, 8, 9, 11], ... ]`

  4. Now, you can distribute peptides across pools using the produced address arrangement. One peptide will be added to one produced address. Keep in mind that peptides should be ordered as they overlap.

      `pools, peptide_address = cpp.pooling(lst, addresses, n_pools)`

      Parameters:

      lst : list, list with peptides (ordered)

      addresses : list, produced address arrangement, in lines

      n_pools : int, number of pools

      The function returns `pools` — dictionary with keys as pool indices and values as peptides that should be added to this pool and `peptide_address` — dictionary with peptides as keys and corresponding addresses as values.

      `pools, peptide_address = cpp.pooling(lst=lst, addresses=lines, n_pools=12)`

      `pools`

      > `{0: ['MFVFLVLLPLVSSQCVN',``'VLLPLVSSQCVNLTTRT',``VSSQCVNLTTRTQLPPA', ...],` `1: ['MFVFLVLLPLVSSQCVN',` `'VLLPLVSSQCVNLTTRT',``'TQDLFLPFFSNVTWFHA', ...], ... }`

      `peptide_address`

      > `{'MFVFLVLLPLVSSQCVN': [0, 1, 2, 3],``'VLLPLVSSQCVNLTTRT': [0, 1, 2, 10], ... }`

  5. Now, you can run the simulation using produced pools and peptide_address. The simulation produces a DataFrame with every possible epitope of the provided length and all pools where this epitope is present. This table can be used to interpret the results.

      The function has two regimes: with and without drop-outs. Without drop-outs, it returns a table as there were no mistakes, and all pools that should be activated were activated. With drop-outs, it returns a table with all possible mistakes (i.e. all possible non-activated pools). This option will need time to be generated, usually several minutes, although it depends on the number of peptides and on occurrence.

      `cpp.run_experiment(lst, peptide_address, ep_length, pools, iters, n_pools, regime)`

      Parameters:

      lst : list, list with peptides (ordered)

      peptide_address : dictionary, peptides addresses produced by pooling

      ep_length : int, expected epitope length, should be less the length of peptide, we recommend using 8

      pools : dictionary, pools produced by pooling

      iters : int, peptide occurrence

      n_pools : int, number of pools

      regime: “with dropouts” or “without dropouts”

      `df = cpp.run_experiment(lst=lst, peptide_address=peptide_address, ep_length=8, pools=pools, iters=iters, n_pools=n_pools, regime='without dropouts')`

      `df`

      | Peptide | Address | Epitope | Act Pools | # of pools | # of epitopes | # of peptides | Remained | # of lost | Right peptide | Right epitope |
      | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
      | MFVFLVLLPLVSSQCVN | [0, 1, 2, 3] | MFVFLVLL | [0, 1, 2, 3] | 4 | 5 | 1 | - | 0 | True | True |
      | MFVFLVLLPLVSSQCVN | [0, 1, 2, 3] | MFVFLVLL | [0, 1, 2, 3] | 4 | 5 | 1 | - | 0 | True | True |
      | … |  |  |  |  |  |  |  |  |  |  |
      | MFVFLVLLPLVSSQCVN | [0, 1, 2, 3] | VLLPLVSS | [0, 1, 2, 3, 10] | 5 | 5 | 2 | - | 0 | True | True |
      | … |  |  |  |  |  |  |  |  |  |  |
      | VLLPLVSSQCVNLTTRT | [0, 1, 2, 10] | VLLPLVSS | [0, 1, 2, 3, 10] | 5 | 5 | 2 | - | 0 | True | True |
      | … |  |  |  |  |  |  |  |  |  |  |

      "Peptide" — peptide sequence

      "Address" — pool indices where this peptide should be added

      "Epitope" — checked epitope from this peptide

      "Act pools" — list with pool indices where this epitope is present

      "# of pools" — number of pools where this epitope is present

      "# of epitopes" — number of epitopes that are present in the same pools (= number of possible peptides upon activation of such pools)

      "# of peptides" — number of peptides in which there are epitopes that are present in the same pools (= number of possible peptides upon activation of such pools)

      "Remained" — only upon regime=”with dropouts”, list of pools remained after mistake

      "# of lost" —  only upon regime=”with dropouts”, number of dropped pools due to mistake

      "Right peptide" — Boolean, whether the peptide is present in the list of possible peptides

      "Right epitope" — Boolean, whether the peptide is present in the list of possible peptides

      To interpret the results of the experiment, you need to find all rows where the “Act Pools” column contains your combination of activated pools. Then, you will know all possible peptides and epitopes that could lead to the activation of such a combination of pools.

      If you can not find your combination of activated pools in the table, here is the sequence of actions.

      After the experiment, you will know the number of activated pools. This number depends on the length of overlap and the length of the expected epitope. You can check the distribution of epitope presence in your peptides using `cpp.how_many_peptides(lst, ep_length)` function. The number of activated pools would be equal to peptide occurrence plus one per additional peptide sharing this epitope.

      This way, if the epitope is present only in 1 peptide (usually, it is the case for epitopes at the ends of the protein), then the number of activated pools is equal to peptide occurrence. If the epitope is present in two peptides, then the number of activated pools is equal to peptide occurrence +1.

      If overlap length is consistent across all peptides, then the number of activated pools would be the same for almost all epitopes (except for the epitopes at the ends of the protein). Although even if the overlap is inconsistent, you can use the analysis, but it will hinder the interpretation of the results in some cases.

      If a shift length between two peptides is equal to or less than the expected epitope length divided by two, then the number of activated pools should be equal to the peptide occurrence value + 1.

      If the number of activated pools is less than according to the rule described above, then three options are possible:

      - The target peptide is the peptide at the end of your peptide list, and the target epitope is located not in an overlap of this peptide with the next one. This could be checked easily: if your activated pools are not the same as the activated pools for any epitope from the first or last peptide, then you should check our second option.
      - For the target peptide, overlap with its neighbor is less than usual, and therefore target epitope is not shared by the usual number of peptides. You can check that using `cpp.all_overlaps(lst)` or `cpp.how_many_peptides(lst, ep_length)`. Nevertheless, given the absence of drop-outs, you still should be able to find the target peptide in the table with simulation results by searching for all rows where the “Act Pools” column contains your combination of activated pools.
      - Some pools were not activated, although they should be; then, we recommend using the “with drop-outs” regime of the simulation. It imitates drop-outs of all possible pools, so you should be able to find your case in the resulting table.

      If the number of activated pools is higher than according to the rule described above, then two options are possible:

      - For the target peptide, overlap with its neighbor is bigger than usual, and therefore target epitope is shared between more peptides. You can check that using `cpp.all_overlaps(lst)` or `cpp.how_many_peptides(lst, ep_length)`. Nevertheless, given the absence of drop-outs, you still should be able to find the target peptide in the table with simulation results by searching for all rows where the “Act Pools” column contains your combination of activated pools.
      - Some pools were activated, although they should not be. This issue is not addressed in the package.

      `df = cpp.run_experiment(lst=lst, peptide_address=peptide_address, ep_length=8, pools=pools, iters=iters, n_pools=n_pools, regime='with dropouts')`

      `df`

      | Peptide | Address | Epitope | Act Pools | # of pools | # of epitopes | # of peptides | Remained | # of lost | Right peptide | Right epitope |
      | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
      | MFVFLVLLPLVSSQCVN | [0, 1, 2, 3] | MFVFLVLL | [0, 1, 2, 3] | 4 | 40 | 12 | [0, 1, 2] | 1 | True | False |
      | MFVFLVLLPLVSSQCVN | [0, 1, 2, 3] | MFVFLVLL | [0, 1, 2, 3] | 4 | 76 | 25 | [0, 1, 3] | 1 | True | False |
      | … |  |  |  |  |  |  |  |  |  |  |
      | RTQLPPAYTNSFTRGVY | [8, 9, 10, 11] | RTQLPPAY | [0, 8, 9, 10, 11] | 5 | 5 | 2 | [0, 8, 9, 10, 11] | 0 | True | True |
      | … |  |  |  |  |  |  |  |  |  |  |
      | RTQLPPAYTNSFTRGVY | [8, 9, 10, 11] | TQLPPAYT | [0, 8, 9, 10, 11] | 5 | 190 | 53 | [8, 9] | 3 | True | True |

      "Peptide" — peptide sequence

      "Address" — pool indices where this peptide should be added

      "Epitope" — checked epitope from this peptide

      "Act pools" — list with pool indices where this epitope is present

      "# of pools" — number of pools where this epitope is present

      "# of epitopes" — number of epitopes that are present in the same pools (= number of possible peptides upon activation of such pools)

      "# of peptides" — number of peptides in which there are epitopes that are present in the same pools (= number of possible peptides upon activation of such pools)

      "Remained" — only upon regime=”with dropouts”, list of pools remained after mistake

      "# of lost" —  only upon regime=”with dropouts”, number of dropped pools due to mistake

      "Right peptide" — Boolean, whether the peptide is present in the list of possible peptides

      "Right epitope" — Boolean, whether the peptide is present in the list of possible peptides

      “Right peptide” and “Right epitope” columns are needed to check the algorithm of dropped pool recovery. Either “Right peptide” or “Right epitope” should contain the value “True”; otherwise, recovery was unsuccessful.

      Also, the regime “with drop-outs” can not differentiate between dropped pools due to a mistake and absent pools due to experiment design. This way, for epitopes located at the end of proteins, the algorithm would think that pools were dropped and would try to recover them. Because of that, if you suspect the epitope located at the end of the peptide to be the target epitope, we recommend first using the “without drop-outs” regime. You can look at the sequence of actions described above. The same applies to peptides with longer overlap. So, we strongly recommend using peptides with consistent overlap length.

  6. *[optional] To avoid mixing pools manually, you can print special punch cards using files with their 3D models produced by this step.

      One punch card is needed for each pool. Each punch card is a thin card with holes located at the spots where the needed peptides are located in the plate. Therefore, each punch card has the number of holes equal to the number of peptides in a pool. Then, this card should be placed on an empty tip box, and a tip should be inserted into each hole. This way, if you are using a multichannel pipette, all tips are already arranged to take only the required peptides.

      [The process you can look up here.]

      To generate the files with 3D models, you need two functions.

      `cpp.pools_stl(peptides_table, pools, rows = 16, cols = 24, length = 122.10, width = 79.97, thickness = 1.5, hole_radius = 4.0 / 2, x_offset = 9.05, y_offset = 6.20, well_spacing = 4.5)`

      Parameters :

      peptides_table : pandas dataframe, a table representing the arrangement of peptides in a plate, is not produced by any function in the package

      pools : pandas dataframe, a table with a pooling scheme, where one row represents each pool, pool index is the index column, and a string with all peptides added to this pool separated by “;” is “Peptides” column.

      rows : 16,  number of rows in your plate with peptides

      cols : 24, number of columns in your plate with peptides

      length : 122.10, length of the plate in mm

      width : 79.97, width of the plate in mm

      thickness : 1.5, desired thickness of the punch card, in mm

      hole_radius : 2.0, the radius of the holes in mm, should be adjusted to fit your tips

      x_offset : 9.05, the margin along the X axis for the A1 hole, in mm

      y_offset : 6.20, the margin along the Y axis for the A1 hole, in mm

      well_spacing : 4.5, the distance between wells, in mm

      The function returns dictionary with Mesh objects. The rendering of 3D models is a long process, so it could take time.

      `meshes_list = cpp.pools_stl(peptides_table, pools, rows = 16, cols = 24, length = 122.10, width = 79.97, thickness = 1.5, hole_radius = 4.0 / 2, x_offset = 9.05, y_offset = 6.20, well_spacing = 4.5)`

      Then you can export generated files:

      `cpp.zip_meshes_export(meshes_list)`

      Parameters :

      meshes_list : dictionary with mesh objects produced by `cpp.pools_stl()`

      The function exports generated STL files in the .zip archive. Then, you can send these STL files directly to a 3D printer. We recommend writing the index of the pool on the punch card. Also, you can check the generated STL file using OpenSCAD.




  `factorial(num)`

  combination(n, k):

  find_possible_k_values(n, l):



  find_q_r(n):

  bgc(n, s = None):

  n_bgc(n):

  computing_ab_i_odd(s_2, l, v):

  m_length_BGC(m, n):

  gc_to_address(s_2, iters, n):

  union_address(address, union):

  address_union(address, union):

  hamiltonian_path_AU(size, point, t, unions, path=None):

  variance_score(bit_sums, s):

  return_address_message(code, mode):

  binary_union(bin_list):

  hamming_distance(s1, s2):

  sum_bits(arr):

  hamiltonian_path_A(G, size, pt, path=None):

  address_rearrangement_AU(n_pools, iters, len_lst):

  address_rearrangement_A(n_pools, iters, len_lst):



  string_overlap(str1, str2):

  all_overlaps(strings):

  find_pair_with_overlap(strings, target_overlap):

  how_many_peptides(lst, ep_length):



  bad_address_predictor(all_ns):

  pooling(lst, addresses, n_pools):

  pools_activation(pools, epitope):

  epitope_pools_activation(peptide_address, lst, ep_length):

  peptide_search(lst, act_profile, act_pools, iters, n_pools, regime):

  run_experiment(lst, peptide_address, ep_length, pools, iters, n_pools, regime):



  stl_generator(rows, cols, length, width, thickness, hole_radius, x_offset, y_offset, well_spacing,
  coordinates):

  pools_stl(peptides_table, pools, rows = 16, cols = 24, length = 122.10, width = 79.97,
  thickness = 1.5, hole_radius = 4.0 / 2, x_offset = 9.05, y_offset = 6.20, well_spacing = 4.5):

  zip_meshes_export(meshes_list):

  zip_meshes(meshes_list):



  pandas>=1.5.3

  numpy>=1.23.5

  cvxpy>=1.3.2

  trimesh>=3.23.5



  [here link to ShinyApp]


pkgId: 2ca80928a3e58e187a12d7fa5ea1fe4524306368aa7e52a2558198898c5f463c
name: python-combinatorixPy
arch: src
version: 1.1.8
epoch: 0
release: 1
url: https://github.com/bakhras/MixtureDescriptors-II
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combinatorixPy-1.1.8-1.src.rpm
checksum_type: sha256
summary:
  Development of Numerical Features/Descriptors to Describe Complex Materials for Machine Learning Modeling

description:
  This Python project calculates an combinatorial scheme for mixture descriptors of multi-component materials. The algorithm processes input from two `.csv` files and computes combinatorial mixture descriptors. This code computes combinatorial mixture descriptors based on cartesian product which is cartesian product of N sets of $D_1 \times D_2 \times \dots \times D_N$ belonging to constituents' descriptors of each mixture, while N is the number of components.



  CombinatorixPy is a Python package designed to generate combinatorial mixture descriptors for multi-component materials. It processes input data from two CSV files to compute these descriptors, facilitating advanced analysis in materials science.



  - **Descriptor Generation**: Creates mixture descriptors using a combinatorial approach based on Cartesian product, which is the Cartesian product of N sets of $D_1 \times D_2 \times \dots \times D_N$ belonging to constituents' descriptors of each mixture, where N is the number of components.
  - **Data Processing**: Handles input from CSV files containing individual descriptors and mole fraction values for each component in mixtures.
  - **Filtering**: Supports filtering of constant and nearly constant descriptors, as well as highly correlated pairs, with adjustable thresholds.


  The algorithm requires two input files:

  1. Descriptors File: Contains individual descriptors for each component.
  2. Mole Fraction File: Contains mole fraction values for each component in each mixture.
  The main function, mixture_descriptors_to_csv, processes these inputs and generates a CSV file.






  Ensure you have Python 3.x installed. You will also need `pip` to install the package.


  You can install the package in two different ways depending on whether you want to install from the local directory or directly from PyPI:

  Option 1: Install from Local Directory
     1. **Download the Package:**
        - Clone the repository or download the ZIP file from GitHub.
        - Extract the contents of the ZIP file.

     2. **Install the Package:**
        - Open a command-line interface (CLI).
        - Navigate to the directory containing the extracted package files.
        - Run the following command to install the package:

        ```bash
        pip install .
        ```
  Option 2: Install from PyPI
  If you prefer to install the package directly from PyPI https://pypi.org/project/combinatorixPy/. You can use the following command, Be sure to replace 1.0.1 with the latest version number as updates become available:

     ```bash
     pip install combinatorixPy
     ```



  After installing the package, you can use it in your Python code. Hereâ€™s a basic example of how to use the main function:


  ```python

  from combinatorixPy import initialize_dask_cluster, Usageget_result

  config = {
          'n_workers': 1,
          'threads_per_worker': 30,
          'memory_limit': '100GB',
          'timeout': 300
      }


      
      cluster = initialize_dask_cluster(config)
      client = Client(cluster)


  get_result(
      descriptors_file_path='path/to/descriptors.csv',
      mole_fraction_file_path='path/to/mole_fractions.csv',
      output_directory='path/to/output',
      constant_threshold=0.01,
      correlation_threshold=0.9,
      batch_number=100000,
      client
  )
  ```
  OR

  ```python
  from combinatorixPy import initialize_dask_cluster, Usageget_result

  config = {
      'scheduler_address': 'tcp://localhost:8786'  # Replace with your scheduler's address
  }

      cluster = initialize_dask_cluster(config)
      client = Client(cluster)


  get_result(
      descriptors_file_path='path/to/descriptors.csv',
      mole_fraction_file_path='path/to/mole_fractions.csv',
      output_directory='path/to/output',
      constant_threshold=0.01,
      correlation_threshold=0.9,
      batch_number=100000,
      client
  )


  ```


  After installation, you can use the package's functions in your Python code. The main function get_result requires seven arguments:
  1- descriptors_file_path: Path to the CSV file containing individual descriptors for each component.
  2- mole_fraction_file_path: Path to the CSV file with mole fraction values for each component in each mixture.
  3- output_directory: Directory path where the resulting CSV file will be saved.
  4- constant_threshold: Threshold for filtering out constant and nearly constant descriptors.
  5- correlation_threshold: Threshold for removing highly correlated descriptor pairs.
  6- batch_number: Batch number for processing highly correlated pairs due to large correlation matrices.
  7- client: An instance of a dask.distributed.Client



  This project is licensed under the GNU General Public License - see the LICENSE file for details.


pkgId: 4bbb437a91881a7f93748189c3db7815822ceba4bf8b7f98a824d623ad09ae1a
name: python-combinatorlite
arch: src
version: 2.0
epoch: 0
release: 1
summary: The programming model to integrate AI components
url: https://github.com/swarna-kpaul/combinatorlite
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combinatorlite-2.0-1.src.rpm
checksum_type: sha256
description:
  | Full Name | short name | Description|
  |-----------|------------|------------|
  | initWorld | iW | Initializes the environment|
  | constant  | K  | Outputs a constant value as set during node creation |
  | identity  | id  | Outputs the input value unchanged |
  | add  | +  | Adds two input numbers. Joins two lists. Updates 2nd key-value pair in the 1st. |
  | subtract  | -  | Subtracts the number in 2nd input port from the 1st |
  | multiply  | *  | Multiplies two numbers |
  | divide  | /  | Divides the number in 1st input port with respect to the 2nd |
  | exponent  | ^  | Raises the number in the 1st input port to the power of the 2nd |
  | conjunction  | &  | Does logical AND operation between two inputs |
  | disjunction  | \|  | Does logical OR operation between two inputs |
  | negate  | !  | Inverts the input boolean value |
  | greater  |>  | Outputs True if 1st input is greater than second else False |
  | equal  |=  | Outputs True if 1st input is equal to second else False |
  | emptylistordict  |nl  | Outputs empty key-value pair if input is 'keyvalue' else empty list |
  | head  |hd  | Outputs 1st element of the list |
  | tail  |tl | Outputs rest of the list except the 1st element |
  | pop  |pop | Outputs the _n_ th element from the list in the 2nd input port. The value _n_ should be provided in the 1st input port. It fetches the value corresponding to the key _k_ if 1st input is a key-value pair. In that case the 2nd input should provide the key _k_.  |
  |append| cn | Appends an element _e_ to the list provided in the 2nd input, where the 1st input provides the element _e_ |
  |addkey| ak | Adds a key value pair to the key-value pairs provided in the 1st input. The 2nd input should provide the key and 3rd the value. |
  |condition| if | Executes the parent graph connected to 2nd input port if 1st input is True else the parent graph of 3rd input port is executed. |
  |lambdagraph| lg | Outputs the parent graph as subgraph. The iW node in the subgraph is replaced with an identity node. Any other initial nodes in the subgraph is connected to the newly created idenity node. |
  |apply| ap | Outputs the parent graph as subgraph. The iW node in the subgraph is replaced with an identity node. Any other initial nodes in the subgraph is connected to the newly created idenity node. |
  |fmap| fm | Converts the subgraph corresponding to parentnode1, a function and thereby applies it to each element of the list supplied in the input port 2. It outputs the new list. |
  |zip| zp | Joins two list element wise. The two list should be provided in two input ports. It outputs a list of lists. |
  |aggregator| ag | Aggregates the element of a list by an aggregator function. The aggregator function should be provided in input port 1 and the list in input port 2. |
  |loop| lp | Converts the subgraph corresponding to parentnode1, a function and applies it _n_ number of times to its output. The initial argument of the function will be _n_ , where _n_ is supplied as an integer to its input port 2. |
  |recurse| rc | Takes 2 function and one data value of any type as input. The function supplied to input port 1 is applied recursively on the 3rd input until stopping condition is met. The function supplied to input port 2 is applied on 3rd input to evaluate the stopping condition. |


pkgId: 36c41791240302ad03ad8f69e0adb2bbf6e8adfae4d3dcb33e101133c50cf340
name: python-combine
arch: src
version: 2.17.0
epoch: 0
release: 1
summary: A straightforward static site builder.
url: https://combine.dropseed.dev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combine-2.17.0-1.src.rpm
checksum_type: sha256
description:
  **Build a straightforward marketing or documentation website with the power of [Jinja](http://jinja.pocoo.org/).
  No fancy JavaScript here &mdash; this is just like the good old days.**

  Put your site into the "content" directory and Combine will:

  - Render files using Jinja
  - Create pretty URLs ("file-system routing")
  - Inject variables
  - Run custom build steps (like building Tailwind)

  Most sites follow a simple pattern.

  Create a `base.template.html`:

  ```html+jinja
  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>My site</title>
  </head>
  <body>
      {% block content %}{% endblock %}
  </body>
  </html>
  ```

  And use it (ex. `pricing.html`):

  ```html+jinja
  {% extends "base.template.html" %}

  {% block content %}
  <div class="pricing">
      <div class="flex">
          ...
      </div>
  </div>
  {% endblock %}
  ```

  In the end, you get a static HTML site that can be deployed almost anywhere.


pkgId: 666d6b788df7e9baa0ddcd9495dc383bf089278cbc33c3ddbf42f99c58429d76
name: python-combined-energy-api
arch: src
version: 0.8
epoch: 0
release: 1
summary: Python interface to the Combined Energy API
url: https://github.com/timsavage/combined-energy-api
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combined-energy-api-0.8-1.src.rpm
checksum_type: sha256
description:
  Provides an async Python 3.11+ interface for the http://combined.energy/ monitoring platform API.

  <p align="center">

  [![Testing](https://github.com/timsavage/combined-energy-api/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/timsavage/combined-energy-api/actions/workflows/tests.yml)
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=timsavage_combined-energy-api&metric=coverage)](https://sonarcloud.io/summary/new_code?id=timsavage_combined-energy-api)
  [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=timsavage_combined-energy-api&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=timsavage_combined-energy-api)
  [![PyPI](https://img.shields.io/pypi/v/combined-energy-api?color=green)](https://pypi.org/project/combined-energy-api)
  ![PyPI - License](https://img.shields.io/pypi/l/combined-energy-api)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  </p>

  > Note this API client is reverse engineered from observing requests being made
  > in the web-application. Please report any failures to read data, this is likely
  > to occur for readings as I am only able to create entries for devices that I
  > have.



  Install from PyPI

  ```shell
  python3 -m pip install combined-energy-api
  ```



  ```python
  import asyncio

  from combined_energy import CombinedEnergy
  from combined_energy.helpers import ReadingsIterator

  async def main():
      """
      Example using Combined Energy API client.
      """

      async with CombinedEnergy(
          mobile_or_email="user@example.com",
          password="YOUR_COMBINED_ENERGY_PASSWORD",
          installation_id=9999,
      ) as combined_energy:

          status = await combined_energy.communication_status()
          print(status)

          
          
          async for readings in ReadingsIterator(combined_energy, increment=300):
              print(readings)
              await asyncio.sleep(300)

  asyncio.run(main())
  ```




  You will need:

  - Python 3.11+
  - poetry
  - pre-commit

  Ensure pre-commit is installed into your git repository with `pre-commit install`.


pkgId: b6b51030069c104c8604b91587e8be753abe1145633552cf96a5cedd02d28973
name: python-combinido-crud-app
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A simple database CRUD application with SQLite and TKinter
url: https://pypi.org/project/combinido-crud-app/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combinido-crud-app-0.4.0-1.src.rpm
checksum_type: sha256
description:
  A simple Python CRUD application using Tkinter and TKBootstrap for the GUI and SQLite for the database.



  - Add, update, delete, and search users.
  - Stores user data in an SQLite database.
  - User interface created with Tkinter and styled using ttkbootstrap.
  - Export user data to a CSV file.



  - Python 3.6 or higher
  - `ttkbootstrap` for modern GUI components
  - SQLite (built-in with Python)
  - `csv` for exporting user data



  To install this package, you can use `pip`. Run the following command:


  ```bash

  pip install combinido-crud-app

  ```


  - In a new Python file, import `combinido-crud-app`
  - Run the application using the `run()` function.
  - e.g. "combinido-crud-app.run()"


pkgId: 504aaf10884e49a867629167facf8e05c251f8b9219a3aee4871f11bf480070b
name: python-combo-lock
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A combined process and thread lock
url: https://github.com/forslund/combo-lock
rpm_license: Apache License v2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combo-lock-0.3.0-1.src.rpm
checksum_type: sha256
description:
  The combo-lock is a combination of a process lock and a thread lock. Usable in cases both multiple threads and multiple processes are sharing the same resource such as a file in the file system.

  The module utilizes the FileLock from [filelock](https://pypi.org/project/filelock/) and the standard *Lock* from threading.

  The FileLock uses a filesystem lock so the initialization of the class requires a path for the lock file.



  ```python
  from combo_lock import ComboLock

  lock = ComboLock('/tmp/my.lock')

  with lock:
      write_my_shared_resource()


  ```

  A `NamedLock` will save the lock file to shared memory using [memory-tempfile](https://github.com/mbello/memory-tempfile)

  ```python
  from combo_lock import NamedLock

  lock = NamedLock('some_name')

  with lock:
      write_my_shared_resource()
  ```



  The combo-lock was originally created for [Mycroft-core](https://github.com/mycroftai/mycroft-core) but as it's been useful in other projects a separate release seemed appropriate.


pkgId: 0312388ec36e78cf7c95cfbe7cbe7ff72414be04b21945bbfc1ad3cc32cf0b0e
name: python-combocurve-api-helper
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: A library mapped to ComboCurve's API.
url: https://github.com/petbox-dev/combocurve-api-helper.git
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combocurve-api-helper-1.1.4-1.src.rpm
checksum_type: sha256
description:
   [![PyPi Version](https://img.shields.io/pypi/v/combocurve-api-helper.svg "PyPi Version")](https://github.com/petbox-dev/combocurve-api-helper)
   [Open in Visual Studio Code](https://open.vscode.dev/petbox-dev/combocurve-api-helper)

  Install from Python package repository:
  ```bash
  python -m pip install combocurve-api-helper
  ```
  or install directly from GitHub:
  ```bash
  python -m pip install git+https://github.com/petbox-dev/combocurve-api-helper.git@main
  ```

  Two files are required in `~/.combocurve`:
  - `cc-api.config.json`
  - `combocurve.json`
  These are given by ComboCurve when configuring API access. Example files are provided
  in `./config-examples/` to demonstrate the expected file structures.
  <br>
  `cc-api.config.example.json`:
  ```json
  {
      "apikey": "<apikey>"
  }
   ```
  <br>
  `combocurve.example.json`:
  ```json
  {
    "type": "service_account",
    "project_id": "beta-combocurve",
    "private_key_id": "<private_key_id>",
    "private_key": "<private_key>",
    "client_email": "<client_email>",
    "client_id": "<client_id>",
    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
    "token_uri": "https://oauth2.googleapis.com/token",
    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
    "client_x509_cert_url": "<client_x509_cert_url>"
  }
   ```

  - David Fulford

  MIT License
  Copyright (c) 2023 Petroleum Engineering Toolbox
  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.

rpm_license:
  MIT License  Copyright (c) 2023 Petroleum Engineering Toolbox  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: c5c92f7d3a5ceddf8628dd9f791de648931212ef4b9524fe4e374124c8ca5032
name: python-combocurve-api-v1
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Client library for the ComboCurve REST API
url: https://pypi.org/project/combocurve-api-v1/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combocurve-api-v1-0.2.6-1.src.rpm
checksum_type: sha256
description:
  `combocurve_api` requires the API key and service account provided by ComboCurve, as shown in the example below:

  ```python
  from combocurve_api_v1 import ServiceAccount, ComboCurveAuth


  service_account = ServiceAccount(
      client_email='YOUR_CLIENT_EMAIL',
      client_id='YOUR_CLIENT_ID',
      private_key='YOUR_PRIVATE_KEY',
      private_key_id='YOUR_PRIVATE_KEY_id'
  )




  api_key = 'YOUR_API_KEY'

  combocurve_auth = ComboCurveAuth(service_account, api_key)


  auth_headers = combocurve_auth.get_auth_headers()
  ```

  `combocurve_auth.get_auth_headers()` should be called before every request so that the token can be
  refreshed if it's about to expire. After getting the authentication headers, they can be used with any HTTP client
  library. Below is an example using the [Requests](https://docs.python-requests.org) library:

  ```python
  import requests

  data = [{
      'wellName': 'well 1',
      'dataSource': 'internal',
      'chosenID': '1234'
  }, {
      'wellName': 'well 2',
      'dataSource': 'internal',
      'chosenID': '4321'
  }]
  auth_headers = combocurve_auth.get_auth_headers()
  url = 'https://api.combocurve.com/v1/wells'

  response = requests.put(url, headers=auth_headers, json=data)
  print(response.json())
  ```



  The ComboCurve API only accepts data serialized as JSON and the `Content-Type` header must be `application/json`. Luckily, [Requests](https://docs.python-requests.org) will take care of both things when the data is passed using the `json` parameter, as you saw in the example above. Using the `data` parameter would be less convenient but it works too:

  ```python
  import json

  response = requests.put(url,
                          headers={
                              **auth_headers, 'Content-Type': 'application/json'
                          },
                          data=json.dumps(data))
  ```

  More information here: https://docs.python-requests.org/en/latest/user/quickstart/#more-complicated-post-requests



  When the number of records to be returned for a request is larger than the maximum number of records that can be retrieved in a single response, the requester will need to "paginate", i.e., make multiple requests while there are more records to be returned.

  This package provides a helper to assist with that. It parses the response headers and returns a new URL for the next request, if another request is needed. See this example using the [Requests](https://docs.python-requests.org) library:

  ```python
  from combocurve_api_v1.pagination import get_next_page_url


  auth_headers = combocurve_auth.get_auth_headers()


  url = 'https://api.combocurve.com/v1/wells?take=200'


  has_more = True


  while has_more:
      response = requests.get(url, headers=headers)

      

      url = get_next_page_url(response.headers)
      has_more = url is not None
  ```


pkgId: c0cad186a859c30a06a78f0e2d55e0525c5f77b7756f6e42f5257277f6c61a29
name: python-combomethod
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Decorator indicating a method is both a class and an instance method
url: https://bitbucket.org/jeunice/combomethod
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combomethod-1.0.12-1.src.rpm
checksum_type: sha256
description:
  In some cases, you can fake ``@combomethod`` with ``@classmethod``. In
  the code above, for example, there is no real reference to the class
  or instance, and ``either`` could have been designated a ``@classmethod``,
  since they can be called with either classes or instances. But, there's a
  problem: Class methods *always* pass the class to the method, even if they're
  called with an instance. With this approach, you can never access the
  instance variables. Ouch!
  Alternatively, ``either`` could have been designated a ``@staticmethod``,
  had its ``receiver`` parameter been removed. But while it would then be
  callable from either an instance or a class, in neither case would it pass
  the object the method was called from. There'd never be a way to access
  either the class or instance variables. Ouch again!
  As useful as ``@classmethod`` and ``@staticmethod`` are, they don't handle the
  (occasionally important) corner case where you need to call with either the
  class or an instance *and* you need genuine access to the object doing the
  call. Here's an example that needs this::
      class Above(object):
          base = 10
          def __init__(self, base=100):
              self.base = base
          @combomethod
          def above_base(receiver, x):
              return receiver.base + x
      a = Above()
      assert a.above_base(5) == 105
      assert Above.above_base(5) == 15
      aa = Above(12)
      assert aa.above_base(5) == 17
      assert Above.above_base(5) == 15
  When you need to call with either an instance or a class, and you also care
  about the object doing the calling, ``@combomethod`` rocks and rolls.


pkgId: 8f8cf4d63ea1ad8630439df4887cba536d031c9105360e740a23630c2c182fb6
name: python-combss
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/combss/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combss-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A package implementation of COMBSS, a novel continuous optimisation method toward best subset selection

description:
  This is the package for COMBSS, a novel continuous optimisation method toward best subset selection, developed from the paper Moka et al. (2024)



  This package relies on the following libraries:

  - `numpy` (version 1.21.0 or later): Numerical computing.
  - `scipy` (version 1.7.0 or later): Sparse matrix operations and linear algebra.
  - `scikit-learn` (version 1.0.0 or later): Machine learning and evaluation metrics.

  These will be installed automatically if you install the package via `pip`. Alternatively, they can also be installed manually.


pkgId: 6262fb37c7eef07d831987564fbff010cfa458d97f2d695518610888eacd2573
name: python-combss
arch: src
version: 1.0.2
epoch: 0
release: 1
url: https://pypi.org/project/combss/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-combss-1.0.2-1.src.rpm
checksum_type: sha256
summary:
  A package implementation of COMBSS, a novel continuous optimisation method toward best subset selection

description:
  This is the package for COMBSS, a novel continuous optimisation method toward best subset selection, developed from the paper Moka et al. (2024).

  For a more detaled overview of COMBSS, refer to https://link.springer.com/article/10.1007/s11222-024-10387-8.



  This package relies on the following libraries:

  - `numpy` (version 1.21.0 or later): Numerical computing.
  - `scipy` (version 1.7.0 or later): Sparse matrix operations and linear algebra.
  - `scikit-learn` (version 1.0.0 or later): Machine learning and evaluation metrics.

  These will be installed automatically if you install the package via `pip`. Alternatively, they can also be installed manually.





  Users can install **COMBSS** using the `pip` command-line tool:

  ```bash
  pip install combss
  ```


  For demonstrative purposes, we apply COMBSS on a dataset created beforehand, with X_train, y_train, X_test, y_test generated from a 80-20 train-test split prior to this example.



  To import **COMBSS** after installation, use the following command:

  ```python
  import combss
  ```

  COMBSS is implemented as a class named `model` within the `linear` module. Users can instantiate an instance of the `model` class to utilize its methods:

  ```python

  optimiser = combss.linear.model()
  ```



  To use COMBSS for best subset selection, call the `fit` method within the `model` class. Here are some commonly used arguments:

  - **q**: Maximum subset size. Defaults to min(number of observations, number of predictors).
  - **nlam**: Number of λ values in the dynamic grid. Default is 50.
  - **scaling**: Boolean to enable feature scaling. Default is `False`.

  Example usage 1:

  ```python

  optimiser.fit(X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, q=8, nlam=20, scaling=True)
  ```



  Other arguments include:

  - **t_init**: Initial point for the vector t.
  - **tau**: Threshold parameter for subset mapping.
  - **delta_frac**: Value of δ/n in the objective function.
  - **eta**: Truncation parameter during gradient descent.
  - **patience**: Number of iterations before termination.
  - **gd_maxiter**: Maximum iterations for gradient descent.
  - **gd_tol**: Tolerance for gradient descent.
  - **cg_maxiter**: Maximum iterations for the conjugate gradient algorithm.
  - **cg_tol**: Tolerance for the conjugate gradient algorithm.

  Modified usage example 2:

  ```python

  optimiser.fit(X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, q=10, nlam=50, scaling=True, tau=0.9, delta_frac=20)
  ```



  After fitting, the following attributes can be accessed:

  - **subset**: Indices of the optimal subset.
  - **mse**: Mean squared error on test data.
  - **coef_**: Coefficients of the linear model.
  - **lambda_**: Optimal λ value.
  - **run_time**: Time taken for fitting.
  - **lambda_list**: List of λ values explored.
  - **subset_list**: Subsets obtained for each λ.

  Example:

  ```python
  optimiser.subset


  optimiser.mse

  ```





  ```python

  optimiser.fit(X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, q = 8, nlam = 20, scaling=True)

  optimiser.subset


  optimiser.mse


  optimiser.coef_





  optimiser.lambda_


  optimiser.run_time


  optimiser.lambda_list








  optimiser.subset_list







  ```
  One can observe that a model of size q = 8 was recovered from the training data after approximately 2.59 seconds. The recovered model with elements of indices in the optimiser.subset array achieved a mean squared error of approximately 19.94 on the test data, after a series of up to nlam = 50 values of λ were explored in the dynamic grid search, starting with an null model explored when COMBSS was initialised with λ approximately equal to 65.548.

  One can additionally observe the following output after performing the fitting in the modified code example 2. In this setting, q is instead taken to equal 10, exploring 50 values of λ with feature scaling, a more stringent thresholding value of 𝜏 = 0.9, and taking the fraction delta/n for the objective function equal to 20. All other arguments take their default values.



  ```python

  combssOptimiser.fit(X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, q = 10, nlam = 50, scaling=True, tau = 0.9, delta_frac = 20)

  optimiser.subset


  optimiser.mse


  optimiser.coef_





  optimiser.lambda_


  optimiser.run_time


  optimiser.lambda_list








  optimiser.subset_list







  ```

  One can observe that the changes to tau, delta_frac and nlam result in different values of lambda being explored, with a different navigation of subsets as the threshold parameter 𝜏 is increased in the subset mapping process, and the landscape of the objective function is changed. Consequently, an additional predictor from the true model is recovered at the expense of a larger computational cost.


pkgId: 834006a08b724bb1b3c5e3d5ceb6e108e7c09e3e59e4f5653fb9f0c1a9a960a5
name: python-comeit
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A pure Python project enforcing conventional commits.
url: https://github.com/mariugul/comeit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comeit-0.5.1-1.src.rpm
checksum_type: sha256
description:
  Lints `git` commits in a Conventional Commits manner in pure Python.


  ```sh
  pip install comeit
  ```


pkgId: 2acc6e67cdeeef74fd20c4ead9b34648d677a345110a750a86c5e8e9d66495c8
name: python-comet-common
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: Comet Distributed Security Notification Framework
url: https://github.com/spotify/comet-common
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comet-common-4.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/spotify/comet-common/workflows/comet-common%20CI/badge.svg)](https://github.com/spotify/comet-common/actions)

  This is a Comet plugin.


  Comet is an alert distribution framework which allows you to distribute alerts all the way to the resource owner with customizable owner lookup, de-duplication, alert formatting as well as automated follow up and metrics.

  Built with ❤️ at Spotify


  Please see the [Comet main repository](https://github.com/spotify/comet) for documentation.



  This project adheres to the [Open Code of Conduct][code-of-conduct]. By participating, you are expected to honor this code.

  [code-of-conduct]: https://github.com/spotify/code-of-conduct/blob/master/code-of-conduct.md


pkgId: c93916f87f377cdc673abc0a0926f80108b169d5b5df8089157f2d154fcae1dc
name: python-comet-core
arch: src
version: 2.11.0
epoch: 0
release: 1
summary: Comet Distributed Security Notification Framework
url: https://github.com/spotify/comet-core
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comet-core-2.11.0-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/spotify/comet-core/workflows/comet-core%20CI/badge.svg)](https://github.com/spotify/comet-core/actions)



  Comet is an alert distribution framework which allows you to distribute alerts all the way to the resource owner with customizable owner lookup, de-duplication, alert formatting as well as automated follow up and metrics.

  Built with ❤️ at Spotify


  Please see the [Comet main repository](https://github.com/spotify/comet) for documentation.



  This project adheres to the [Open Code of Conduct][code-of-conduct]. By participating, you are expected to honor this code.

  [code-of-conduct]: https://github.com/spotify/code-of-conduct/blob/master/code-of-conduct.md


pkgId: 3721645b2a96d6eb4f430ee646c392295a6056ec2ef86d7b81b86ebd474b9235
name: python-comet-toolbox
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Dynamic functional connectivity toolbox for multiverse analysis
url: https://github.com/mibur1/dfc-multiverse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comet-toolbox-0.9.1-1.src.rpm
checksum_type: sha256
description:
  <div style="padding-top:1em; padding-bottom: 0.5em;">
  <img src="src/comet/data/img/logo.svg" width =130 align="right" />
  </div>



  [![DOI](https://img.shields.io/badge/DOI-10.1101%2F2024.01.21.576546-blue?logo=arxiv)](https://doi.org/10.1101/2024.01.21.576546) [![PyPI](https://img.shields.io/badge/PyPI-comet--toolbox-orange?logo=PyPI)](https://pypi.org/project/comet-toolbox/)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/2e766745c5c04d4786ea28f7135c193e)](https://app.codacy.com/gh/mibur1/comet/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade) [![Documentation Status](https://readthedocs.org/projects/comet-toolbox/badge/?version=latest)](https://comet-toolbox.readthedocs.io/en/latest/) [![Coverage Status](https://coveralls.io/repos/github/mibur1/dfc-multiverse/badge.svg?branch=main)](https://coveralls.io/github/mibur1/dfc-multiverse?branch=main)




  Please refer to the **[documentation](https://comet-toolbox.readthedocs.io/en/latest/)** for detailed information about the toolbox. The following README will only provide a very brief overview.

  Please also note that the package is in an early stage of development, with frequent changes being made. If you intend to use this package at this stage, please feel free to contact me via the email address in the [`pyproject.toml`](https://github.com/mibur1/dfc-multiverse/blob/main/pyproject.toml) file. Some features are also not yet tested, so there will be bugs (the question is just how many).



  It is recommended to use a dedicated Python environment (e.g. through conda) to mitigate the risk of potential version conflicts. Installation is possible through the Python Package Index (PyPI) or from the source code in this repository:

  ```
  conda create -n comet python==3.11
  conda activate comet
  pip install comet-toolbox
  ```

  Usage of the toolbox is then possible through either the GUI:

  ```
  comet-gui
  ```

  or (for more versatile usage) through the scripting API. For this, **[demo scripts](https://github.com/mibur1/dfc-multiverse/tree/main/tutorials)** are provided as starting points:

  * Demo script for **[calculating dFC](tutorials/example_dfc.ipynb)**
  * Demo script for **[performing multiverse analysis](tutorials/example_multiverse.ipynb)**
  * Demo script for **[multiverse analysis example from the preprint](tutorials/example_analysis.ipynb)** (+ additional visualizations)
  * Demo script for **[graph analysis](tutorials/example_graph.ipynb)**



  <table style="width: 100%; border-collapse: collapse;">
      <tr>
          <th style="text-align: left; padding: 8px; border: 1px solid #ddd;">Functional Connectivity</th>
          <th style="text-align: left; padding: 8px; border: 1px solid #ddd;">Graph Analysis</th>
          <th style="text-align: left; padding: 8px; border: 1px solid #ddd;">Multiverse Analysis</th>
      </tr>
      <tr>
          <td style="vertical-align: top; padding: 8px; border: 1px solid #ddd;">
              <strong>Continuous</strong>
              <ul>
                  <li>Sliding Window Correlation</li>
                  <li>Jackknife Correlation</li>
                  <li>Flexible Least Squares</li>
                  <li>Spatial Distance</li>
                  <li>Temporal Derivatives</li>
                  <li>Phase Synchronization</li>
                  <li>Leading Eigenvector Dynamics</li>
                  <li>Wavelet Coherence</li>
                  <li>Edge-centric connectivity</li>
              </ul>
              <strong>State-Based</strong>
              <ul>
                  <li>SW Clustering</li>
                  <li>Co-activation Patterns</li>
                  <li>Discrete HMM</li>
                  <li>Continuous HMM</li>
                  <li>Windowless</li>
              </ul>
              <strong>Static</strong>
              <ul>
                  <li>Pearson Correlation</li>
                  <li>Partial Correlation</li>
                  <li>Mutual Information</li>
              </ul>
          </td>
          <td style="vertical-align: top; padding: 8px; border: 1px solid #ddd;">
              <strong>Optimized implementation</strong>
              <ul>
                  <li>Average Path Length</li>
                  <li>Global Efficiency</li>
                  <li>Nodal Efficiency</li>
                  <li>Small-World Sigma</li>
                  <li>Small-World Propensity</li>
                  <li>Matching Index</li>
              </ul>
              <strong>Standard Graph Functions</strong>
              <ul>
                  <li>Threshold</li>
                  <li>Binarise</li>
                  <li>Symmetrise</li>
                  <li>Negative weights</li>
                   <li>...</li>
              </ul>
              <strong>BCT Integration</strong>
              <ul>
                  <li>All BCT functions can be<br>used seamlessly fory<br>multiverse analysis</li>
                  <li>Many BCT functions are available in the GUI</li>
              </ul>
          </td>
          <td style="vertical-align: top; padding: 8px; border: 1px solid #ddd;">
              <strong>Simple Definition</strong>
              <ul>
                  <li>Forking paths as<br>python dictionary</li>
                  <li>Analysis pipeline template with decision points</li>
              </ul>
              <strong>Generation</strong>
              <ul>
                  <li>Universes are created<br>as individual scripts</li>
                  <li>Modular approach</li>
              </ul>
              <strong>Analysis</strong>
              <ul>
                  <li>Individual universes</li>
                  <li>Entire multiverse (parallel)</li>
              </ul>
              <strong>Visualization</strong>
              <ul>
                  <li>Multiverse summary</li>
                  <li>Multiverse as a network</li>
                  <li>Specification curve analysis</li>
              </ul>
          </td>
      </tr>
  </table>


pkgId: a454211753dde7e66a05f1c51bb2ac82fcc94314df5a8987e486a6219584d09c
name: python-cometx
arch: src
version: 2.2.18
epoch: 0
release: 1
summary: Python tools for Comet
url: https://github.com/comet-ml/comet-sdk-extensions/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cometx-2.2.18-1.src.rpm
checksum_type: sha256
description:
  ```
     _________  ____ ___  ___  / /__  __
    / ___/ __ \/ __ `__ \/ _ \/ __/ |/_/
   / /__/ /_/ / / / / / /  __/ /__>  <
   \___/\____/_/ /_/ /_/\___/\__/_/|_|
  ```

  Open source extensions for the [Comet](https://www.comet.com/site/?utm_source=cometx&utm_medium=referral&utm_campaign=cometx_2022&utm_content=github) SDK.

  These extensions are created and supported by the community and are
  not an official project of Comet ML. We welcome contributions!



  ```
  pip install cometx
  ```

  To use these command-line functions, you'll need to have your Comet
  API key set in one of the following two ways.

  1. [Environment variables](https://www.comet.com/docs/v2/guides/tracking-ml-training/configuring-comet/?utm_source=cometx&utm_medium=referral&utm_campaign=cometx_2022&utm_content=github#configure-comet-through-environment-variables)
  2. [Comet config file](https://www.comet.com/docs/v2/guides/tracking-ml-training/configuring-comet/?utm_source=cometx&utm_medium=referral&utm_campaign=cometx_2022&utm_content=github#configure-comet-using-the-comet-config-file)

  Either this way:

  ```
  export COMET_API_KEY="YOUR-COMET-API-KEY"
  ```

  or this way:

  ```
  [comet]
  api_key = YOUR-COMET-API-KEY
  ```

  If you are an Comet on-prem user, you'll also need to set the
  `COMET_URL_OVERRIDE` environment variable, or add it to your
  `~/.comet.config` file as below:

  Either this way:

  ```
  export COMET_API_KEY="YOUR-COMET-API-KEY"
  export COMET_URL_OVERRIDE="https://your-companys-comet.com/clientlib/"
  ```

  or this way:

  ```
  [comet]
  api_key = YOUR-COMET-API-KEY
  url_override = https://your-companys-comet.com/clientlib/
  ```



  `cometx` is composed of a series of subcommands that are useful
  independently, and can be used together to create sophisticated tools
  for ML management.

  This section will examine some common uses, followed by a more
  detailed exploration of each subcommand.



  In this section we'll explore some common scenarios.

  1. Copy a specific project from one Comet installation to another
  2. Copy all projects in workspace to a new workspace
  4. Copy specific experiments in a project to new experiments



  A useful idiom is to set your Comet environment variables on the line
  of a subcommand. In this manner, you can set the `COMET_URL_OVERRIDE`
  and `COMET_API_KEY` for different installations.

  Of course, you don't have to set the environment variables if you are
  copying experiments on the same Comet installation.

  Here is how you one could download the experiments in
  WORKSPACE/PROJECT from http://comet.a.com:

  ```shell
  COMET_URL_OVERRIDE=http://comet.a.com/clientlib \
  COMET_API_KEY=A-KEY \
  cometx download WORKSPACE/PROJECT
  ```

  The `cometx download` subcommand downloads all of the Comet experiment
  data into local files. Note that WORKSPACE/PROJECT refers to a
  workspace and project on http://comet.a.com.

  One could then copy the downloaded experiment data with a similar command:

  ```shell
  COMET_URL_OVERRIDE=http://comet.b.com/clientlib \
  COMET_API_KEY=B-KEY \
  cometx copy WORKSPACE/PROJECT NEW-WORKSPACE/NEW-PROJECT
  ```

  Note that WORKSPACE/PROJECT now refers to a directory, and
  NEW-WORKSPACE/NEW-PROJECT refers to a workspace and project on
  http://comet.b.com.



  Similarly, one can copy all of the projects by first downloading them:

  ```shell
  COMET_URL_OVERRIDE=http://comet.a.com/clientlib \
  COMET_API_KEY=A-KEY \
  cometx download WORKSPACE
  ```

  and then copying them:

  ```shell
  COMET_URL_OVERRIDE=http://comet.b.com/clientlib \
  COMET_API_KEY=B-KEY \
  cometx copy WORKSPACE NEW-WORKSPACE
  ```



  Similarly, one can copy a single experiment first downloading it:

  ```shell
  COMET_URL_OVERRIDE=http://comet.a.com/clientlib \
  COMET_API_KEY=A-KEY \
  cometx download WORKSPACE/PROJECT/EXPERIMENT-NAME-OR-ID
  ```

  and then copying it:

  ```shell
  COMET_URL_OVERRIDE=http://comet.b.com/clientlib \
  COMET_API_KEY=B-KEY \
  cometx copy WORKSPACE/PROJECT/EXPERIMENT-NAME-OR-ID NEW-WORKSPACE/NEW-PROJECT
  ```



  * [cometx list](#cometx-list)
  * [cometx download](#cometx-download)
  * [cometx copy](#cometx-copy)
  * [cometx log](#cometx-log)
  * [cometx reproduce](#cometx-reproduce)
  * [cometx delete-assets](#cometx-delete-assets)


  For all subcommands, use the `--help` flag to get additional information.



  This command is used to:

  * get a list of all workspaces that you are a member of
  * get a list of all projects in a workspace
  * get a list of all experiments (by name or key) in a project

  cometx list examples:

  ```
  cometx list WORKSPACE/PROJECT/EXPERIMENT-KEY-OR-NAME
  cometx list WORKSPACE/PROJECT
  cometx list WORKSPACE
  cometx list
  ```



  * `--query` - use to limit the experiments to download (see [experiment.api.query()](https://www.comet.com/docs/v2/api-and-sdk/python-sdk/reference/API/#apiquery) for more information)
  *  `-u`, `--use-name` - use experiment names for experiment folders and listings

  For more information, `cometx list --help`



  This command is used to:

  * copy downloaded data to a new experiment
  * create a symlink from one project to existing experiments

  cometx copy examples:

  ```
  cometx SOURCE DESTINATION
  cometx --symlink SOURCE DESTINATION
  ```

  where SOURCE is:

  * if not `--symlink`, "WORKSPACE/PROJECT/EXPERIMENT", "WORKSPACE/PROJECT/*", or "WORKSPACE/*/*" folder (use quotes)
  * if `--symlink`, then it is a Comet path to workspace or workspace/project

  where DESTINATION is:

  * WORKSPACE
  * WORKSPACE/PROJECT

  Not all combinations are possible:


  | Destination → <br/>Source ↓ | WORKSPACE            | WORKSPACE/PROJECT      |
  |--------------------|----------------------|------------------------|
  | `WORKSPACE/*/*`      | Copies all projects  | N/A                    |
  | `WORKSPACE/PROJ/*`   | N/A                  | Copies all experiments |
  | `WORKSPACE/PROJ/EXP` | N/A                  | Copies experiment      |


  For more information, `cometx copy --help`



  This command is used to:

  * download all workspaces, projects, and experiments of workspaces that you are a member of
  * download all projects, and experiments of a given workspace
  * download all experiments of a given workspace/project

  cometx dowload examples:

  ```
  cometx download WORKSPACE/PROJECT/EXPERIMENT-KEY-OR-NAME [RESOURCE ...] [FLAGS ...]
  cometx download WORKSPACE/PROJECT [RESOURCE ...] [FLAGS ...]
  cometx download WORKSPACE [RESOURCE ...] [FLAGS ...]
  cometx download [RESOURCE ...] [FLAGS ...]
  ```

  Where [RESOURCE ...] is zero or more of the following names:

  * assets
  * html
  * metadata
  * metrics
  * others
  * parameters
  * project - alias for: project_notes, project_metadata
  * run - alias for: code, git, output, graph, and requirements
  * system

  If no RESOURCE is given it will download all of them.



  * `--query` - use to limit the experiments to download (see [experiment.api.query()](https://www.comet.com/docs/v2/api-and-sdk/python-sdk/reference/API/#apiquery) for more information)
  * `--list` - use to list available workspaces, projects, experiments,
      artifacts, or models (same as `cometx list`)
  * `--output` - download resources to folder other than current one
  * `--flat` - don't use the normal hiearchy for downloaded items
  * `--use-name` - use experiment names for folders and listings
  * `--ignore` - don't download the following resources (use one or more
      RESOURCE names from above)
  * `--asset-type` - asset type to match, or leave off to match all
  * `--filename` - filename to match, or leave off to match all
  * `--overwrite` - overwrite any existing files
  * `--force` - don't ask to download, just do it
  * `--help` - this message

  To download artifacts:

  ```
  cometx download WORKSPACE/artifacts/NAME [FLAGS ...]
  cometx download WORKSPACE/artifacts/NAME/VERSION-OR-ALIAS [FLAGS ...]
  ```

  To download models from the model registry:

  ```
  cometx download WORKSPACE/model-registry/NAME [FLAGS ...]
  cometx download WORKSPACE/model-registry/NAME/VERSION-OR-STAGE [FLAGS ...]
  ```

  For more information, `cometx download --help`




  This command is used to log a resource (metrics, parameters, asset,
  etc) file to a specific experiment or experiments.

  cometx log example:

  ```
  cometx log WORKSPACE/PROJECT/EXPERIMENT-KEY-OR-NAME [--type TYPE] FILENAME.EXT
  ```

  where TYPE is the asset type of the filename. TYPE is not needed if the
  filename extension (FILENAME.EXT) is known.

  Known extensions:

  * png
  * jpg
  * gif
  * txt
  * webm
  * mp4
  * ogg
  * ipynb
  * wav
  * mp3

  Known types:

  * asset
  * image
  * text-sample
  * video
  * ipynb
  * audio

  Example to set an other key:value:

  ```
  cometx log WORKSPACE/PROJECT --type other --set "key:value"
  cometx log WORKSPACE/PROJECT/EXPERIMENT-KEY-OR-NAME --type other --set "key:value"
  ```
  The first version will set the other key:value in all experiments in a project, and the second will set the other key:value in the experiment.


  Example to log all items:

  ```
  cometx log WORKSPACE/PROJECT PATH-TO-DOWNLOAD --type all
  cometx log WORKSPACE/PROJECT/EXPERIMENT-KEY-OR-NAME PATH-TO-DOWNLOAD --type all
  ```
  The first version will create an experiment, and the second will log everything to an existing experiment.



  * `--query` - use to limit the experiments to download (see [experiment.api.query()](https://www.comet.com/docs/v2/api-and-sdk/python-sdk/reference/API/#apiquery) for more information)
  * `--type` - the type of item to log
  * `--set` - the "key:value" to log

  For more information, `cometx log --help`



  To delete experiments assets:

  ```
  cometx delete-assets WORKSPACE/PROJECT --type=image
  cometx delete-assets WORKSPACE/PROJECT/EXPERIMENT --type=all
  ```
  Type can be valid asset tupe, including:

  * all
  * asset
  * audio
  * code
  * image
  * notebook
  * text-sample
  * video

  For more information, `cometx delete-assets --help`



  ```
  cometx reproduce [-h] [--run] [--executable EXECUTABLE] COMET_PATH OUTPUT_DIR
  ```

  For more information, `cometx reproduce --help`



  WARNING: Running the tests will create experiments, models, assets, etc.
  in your default workspace if not set otherwise.

  To run the tests, you can either export all of these items in the
  environment:

  ```shell
  $ export COMET_USER="<USERNAME>"
  $ export COMET_WORKSPACE="<WORKSPACE>"
  $ export COMET_API_KEY="<API-KEY>"
  $ pytest tests
  ```

  Or, define `workspace` and `api_key` in your ~/.comet.config file:

  ```shell
  $ export COMET_USER="<USERNAME>"
  $ pytest tests
  ```


pkgId: f35b1d1070bdeb5573173d9335df6e2b441caf5989071ba5555f0adb7ea7f816
name: python-comfy-api-simplified
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: A simple way to schedule ComfyUI prompts with different parameters
url: https://github.com/deimos-deimos/comfy_api_simplified
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comfy-api-simplified-1.2.1-1.src.rpm
checksum_type: sha256
description:
  This is a small python wrapper over the [ComfyUI](https://github.com/comfyanonymous/ComfyUI) API. It allows you to edit API-format ComfyUI workflows and queue them programmaticaly to the already running ComfyUI.

  I use it to iterate over multiple prompts and key parameters of workflow and get hundreds of images overnight to cherrypick from.



  Only Basic auth and no auth (for local server) are supported.



  `pip3 install comfy_api_simplified`





  You would like to have your node titles unique. Usually both positive and negative prompts have title "CLIP Text Encode (Prompt)", you would like to at least give them different names in case you would like to change it's parameters from python.



  In ComfyUI settings, check "Enable Dev mode Options":
  ![Alt text](misc/dev_opt.png)



  <img src="misc/download.png" width="150">





  ```python
  from comfy_api_simplified import ComfyApiWrapper, ComfyWorkflowWrapper


  api = ComfyApiWrapper("http://127.0.0.1:8188/")


  wf = ComfyWorkflowWrapper("workflow_api.json")



  wf.set_node_param("Empty Latent Image", "batch_size", 2)
  wf.set_node_param("negative", "text", "embedding:EasyNegative")


  results = api.queue_and_wait_images(wf, "Save Image")
  for filename, image_data in results.items():
      with open(f"{filename}", "wb+") as f:
          f.write(image_data)

  ```

  More examples:

  - Queue prompt and get result images [example](examples/queue_with_different_params.py).

  - Queue many prompts and do not wait for completion [example](examples/queue_and_wait_result.py).

  - Send input image and then call i2i workflow [example](examples/send_input_image.py).



  There are some other approaches to use Python with ComfyUI out there.

  If you are looking to conver your workflows to backend server code, check out [ComfyUI-to-Python-Extension](https://github.com/pydn/ComfyUI-to-Python-Extension)

  If you are looking to use running ComfyUI as backend, but declare workflow in Python imperatively, check out [ComfyScript](https://github.com/Chaoses-Ib/ComfyScript/tree/main).



  If you try to run queue_and_wait_images in async method, it may give you an error since there is already async code inside.
  As a workaround, you can use

  ```python
  import nest_asyncio
  nest_asyncio.apply()
  ```

  for now.


pkgId: d1872d9ee4b4d4fef6732036ea9bfb85e8470ae0bcc26bc6cee691295856bf25
name: python-comfydeploy
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Python Client SDK Generated by Speakeasy
url: https://github.com/comfy-deploy/comfy-deploy-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comfydeploy-0.4.1-1.src.rpm
checksum_type: sha256
description:
  <div align="left">
      <a href="https://speakeasyapi.dev/"><img src="https://custom-icon-badges.demolab.com/badge/-Built%20By%20Speakeasy-212015?style=for-the-badge&logoColor=FBE331&logo=speakeasy&labelColor=545454" /></a>
      <a href="https://opensource.org/licenses/MIT">
          <img src="https://img.shields.io/badge/License-MIT-blue.svg" style="width: 100px; height: 28px;" />
      </a>
  </div>




  It has been generated successfully based on your OpenAPI spec. However, it is not yet ready for production use. Here are some next steps:
  - [ ] 🛠 Make your SDK feel handcrafted by [customizing it](https://www.speakeasyapi.dev/docs/customize-sdks)
  - [ ] ♻️ Refine your SDK quickly by iterating locally with the [Speakeasy CLI](https://github.com/speakeasy-api/speakeasy)
  - [ ] 🎁 Publish your SDK to package managers by [configuring automatic publishing](https://www.speakeasyapi.dev/docs/advanced-setup/publish-sdks)
  - [ ] ✨ When ready to productionize, delete this section from the README

  <!-- Start SDK Installation [installation] -->


  PIP
  ```bash
  pip install comfydeploy
  ```

  Poetry
  ```bash
  poetry add comfydeploy
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from comfydeploy import ComfyDeploy

  s = ComfyDeploy(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.run.get(run_id="<value>")

  if res.object is not None:
      
      pass
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from comfydeploy import ComfyDeploy

  async def main():
      s = ComfyDeploy(
          bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
      )
      res = await s.run.get_async(run_id="<value>")
      if res.object is not None:
          
          pass

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->




  * [get](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/run/README.md#get) - Get workflow run output
  * [create](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/run/README.md#create) - Run a workflow via deployment_id



  * [get_upload_url](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/files/README.md#get_upload_url) - Upload any files to the storage



  * [get](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/websocket/README.md#get) - Get a websocket url for a specific deployment



  * [get_auth_response_request_id_](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/comfyui/README.md#get_auth_response_request_id_) - Get an API Key with code
  * [post_workflow](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/comfyui/README.md#post_workflow) - Upload workflow from ComfyUI
  * [get_workflow_version_version_id_](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/comfyui/README.md#get_workflow_version_version_id_) - Get comfyui workflow
  * [get_workflow_id_](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/comfyui/README.md#get_workflow_id_) - Get comfyui workflow



  * [post_machine_endpoint](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/workflows/README.md#post_machine_endpoint) - Create an endpoint for a machine
  * [get_all](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/workflows/README.md#get_all) - Retrieve workflows
  * [create](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/workflows/README.md#create) - Create a new workflow
  * [get](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/workflows/README.md#get) - Retrieve a specific workflow by ID
  * [get_outputs](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/workflows/README.md#get_outputs) - Retrieve the most recent outputs for a workflow



  * [get_input_definition](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/deployment/README.md#get_input_definition) - Get comfyui workflow inputs definition
  * [get](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/deployment/README.md#get) - Get all deployed workflows



  * [post_gpu_event](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/machine/README.md#post_gpu_event) - Register a machine event
  * [list_events](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/machine/README.md#list_events) - Get recent gpu events
  * [get_v1_machines](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/machine/README.md#get_v1_machines) - Retrieve all machines for a user
  * [post_v1_machines](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/machine/README.md#post_v1_machines) - Create a new machine
  * [get_v1_machines_machine_id_](https://github.com/comfy-deploy/comfy-deploy-python/blob/master/docs/sdks/machine/README.md#get_v1_machines_machine_id_) - Retrieve a specific machine by ID
  <!-- End Available Resources and Operations [operations] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations.  All operations return a response object or raise an error.  If Error objects are specified in your OpenAPI Spec, the SDK will raise the appropriate Error type.

  | Error Object                 | Status Code                  | Content Type                 |
  | ---------------------------- | ---------------------------- | ---------------------------- |
  | errors.GetRunResponseBody    | 400                          | application/json             |
  | errors.GetRunRunResponseBody | 500                          | application/json             |
  | errors.SDKError              | 4xx-5xx                      | */*                          |



  ```python
  from comfydeploy import ComfyDeploy
  from comfydeploy.models import errors

  s = ComfyDeploy(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )

  res = None
  try:
      res = s.run.get(run_id="<value>")

  except errors.GetRunResponseBody as e:
      
      raise(e)
  except errors.GetRunRunResponseBody as e:
      
      raise(e)
  except errors.SDKError as e:
      
      raise(e)

  if res.object is not None:
      
      pass

  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  You can override the default server globally by passing a server index to the `server_idx: int` optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the indexes associated with the available servers:

  | # | Server | Variables |
  | - | ------ | --------- |
  | 0 | `https://www.comfydeploy.com/api` | None |



  ```python
  from comfydeploy import ComfyDeploy

  s = ComfyDeploy(
      server_idx=0,
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.run.get(run_id="<value>")

  if res.object is not None:
      
      pass

  ```




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from comfydeploy import ComfyDeploy

  s = ComfyDeploy(
      server_url="https://www.comfydeploy.com/api",
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.run.get(run_id="<value>")

  if res.object is not None:
      
      pass

  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from comfydeploy import ComfyDeploy
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = ComfyDeploy(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from comfydeploy import ComfyDeploy
  from comfydeploy.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = ComfyDeploy(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name          | Type          | Scheme        |
  | ------------- | ------------- | ------------- |
  | `bearer_auth` | http          | HTTP Bearer   |

  To authenticate with the API the `bearer_auth` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from comfydeploy import ComfyDeploy

  s = ComfyDeploy(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.run.get(run_id="<value>")

  if res.object is not None:
      
      pass

  ```
  <!-- End Authentication [security] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from comfydeploy import ComfyDeploy
  from comfydeploy.utils import BackoffStrategy, RetryConfig

  s = ComfyDeploy(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.run.get(run_id="<value>",
      RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

  if res.object is not None:
      
      pass

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from comfydeploy import ComfyDeploy
  from comfydeploy.utils import BackoffStrategy, RetryConfig

  s = ComfyDeploy(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )


  res = s.run.get(run_id="<value>")

  if res.object is not None:
      
      pass

  ```
  <!-- End Retries [retries] -->

  <!-- Start Debugging [debug] -->


  To emit debug logs for SDK requests and responses you can pass a logger object directly into your SDK object.

  ```python
  from comfydeploy import ComfyDeploy
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = ComfyDeploy(debug_logger=logging.getLogger("comfydeploy"))
  ```
  <!-- End Debugging [debug] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation.
  We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.


pkgId: 6a1938b5caf8e204674daabf3ee163de0ca85ac3a49a79d130e29d4d755f1d96
name: python-comfyui-tooling-nodes
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Acly/comfyui-tooling-nodes
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comfyui-tooling-nodes-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Provides nodes and API geared towards using ComfyUI as a backend for external tools.



  ComfyUI exchanges images via the filesystem. This requires a
  multi-step process (upload images, prompt, download images), is rather
  inefficient, and invites a whole class of potential issues. It's also unclear
  at which point those images will get cleaned up if ComfyUI is used
  via external tools.



  Loads an image from a PNG embedded into the prompt as base64 string.
  * Inputs: base64 encoded binary data of a PNG image
  * Outputs: image (RGB) and mask (alpha) if present



  Loads a mask (single channel) from a PNG embedded into the prompt as base64 string.
  * Inputs: base64 encoded binary data of a PNG image
  * Outputs: the first channel of the image as mask



  Sends an output image over the client WebSocket connection as PNG binary data.
  * Inputs: the image (RGB or RGBA)

  This will first send one binary message for each image in the batch via WebSocket:
  ```
  12<PNG-data>
  ```
  That is two 32-bit integers (big endian) with values 1 and 2 followed by the PNG binary data. There is also a JSON message afterwards:
  ```
  {'type': 'executed', 'data': {'node': '<node ID>', 'output': {'images': [{'source': 'websocket', 'content-type': 'image/png', 'type': 'output'}, ...]}, 'prompt_id': '<prompt ID>}}
  ```



  When integrating ComfyUI into tools which use layers and compose them on the fly, it is useful to only receive relevant masked regions.



  Copies a mask into the alpha channel of an image.
  * Inputs: image and mask
  * Outputs: RGBA image with mask used as transparency



  There are various types of models that can be loaded as checkpoint, LoRA, ControlNet, etc. which cannot be used interchangeably. The following API helps to categorize and filter them.



  Lists available models with additional classification info.
  * Paramters: _none_
  * Output: list of model files
      ```
      {
          "checkpoint_file.safetensors": {
              "base_model": "sd15"|"sd20"|"sd21"|"sdxl"|"ssd1b"|"svd",
              "is_inpaint": true|false,
              "is_refiner": true|false
          },
          ...
      }
      ```
      The entry is `{"base_model": "unknown"}` for models which are not in safetensors format or do not match any of the known base models.

  _Note: currently only supports checkpoints. May add other models in the future._



  Download the repository and unpack into the `custom_nodes` folder in the ComfyUI installation directory.

  Or clone via GIT, starting from ComfyUI installation directory:
  ```
  cd custom_nodes
  git clone https://github.com/Acly/comfyui-tooling-nodes.git
  ```

  Restart ComfyUI and the nodes are functional.


pkgId: 4ec6f739f6c3e91c22c93c11de155c1f566a2069ac6e34258a920efbc4d6f6a9
name: python-comfyui-types
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: A small helper library to add types for custom ComfyUI nodes.
url: https://github.com/tkreuziger/comfyui-types
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-comfyui-types-1.3.3-1.src.rpm
checksum_type: sha256
description:
  This is a small helper project to make it easier to write custom nodes for
  ComfyUI. Usually, types in ComfyUI are represented as string constants for
  parameter and return types, which can cause errors during development, as it is
  easy to mistype. With such string constants, your IDE cannot recognize the types
  and offer suggestions or alarm you abour errors. Such an error will only be
  found, when ComfyUI is restarted and the custom node is executed.

  This project provides a small set of shallow Python classes that provide typing,
  so an IDE can pick up correct types and show errors before the node is imported,
  making development much faster and reducing debugging.



  Install from PyPI:

  ```bash
  pip install comfyui-types
  ```

  Or via conda:

  ```bash
  conda install tkreuziger::comfyui_types
  ```

  Alternatively, you can install the package locally from source:

  ```bash
  git clone https://github.com/tkreuziger/comfyui-types.git ./comfyui_types
  pip install ./comfyui_types
  ```





  Your custom node must derive from `ComfyUINode`:

  ```python
  from comfyui_types import ComfyUINode

  class MyCustomNode(ComfyUINode):
      """Your custom node."""
  ```

  This does most of the heavy lifting and ensures that ComfyUI can import your
  node correctly.



  Next you can define some meta parameters:

  ```python
  from comfyui_types import ComfyUINode

  class MyCustomNode(ComfyUINode):
      function = 'execute'
      category = 'mycategory/mynodes'
      display_name = 'My Custom Node'
      deprecated = False
      experimental = False
  ```

  - `function` works the same as the traditional `FUNCTION` member, but has a
  default value of `execute`. This means that you can save yourself writing one
  line of code, if you simply name the method of your node that you want to be
  executed `execute`.
  - The `category` member is equivalent to the `CATEGORY` member, it is simply
  written in lower case letters for consistency.
  - `display_name` defines the name that will be exported and used for showing
  your name in the ComfyUI frontend. If you do not define this member, it will
  simply use the name of the class, i.e. `MyCustomNode` in this example,
  automatically. This is only relevant, if you use the [exporter
  function](#exporting-custom-nodes), described below, otherwise it can safely
  be ignored.
  - `deprecated` and `experimental` are simply aliases for `DEPRECATED` and
  `EXPERIMENTAL` respectively



  You define your input parameters as fields of the node class. All available
  input types are described in the [documentation](/docs/input_types.md).

  By default, the name of the field will be used as the name that is shown in the
  UI. You can override this behavior, by passing the optional parameter
  `display_name`, when defining your inputs. Any other options are defined as
  parameters of the input field:

  ```python
  from comfyui_types import ComfyUINode, StringInput, FloatInput

  class MyCustomNode(ComfyUINode):
      pos_prompt_text = StringInput(default='masterpiece', multiline=True)
      neg_prompt_text = StringInput(required=False, default='b&w', multiline=True)
      custom_weight = FloatInput(default=1.0, min=0.0, max=1.0, step=0.1)
      secret_parameter = FloatInput(hidden=True, display_name='super secret')
  ```

  Input parameters can be `required`, `optional`, or `hidden` (see [Input
  type](/docs/input_types.md#inputtype) for more information). Usually, most
  parameters are required, so the default value for `required` is `True`. If you
  need an optional parameter, pass in `required=False`. If you want a hidden
  parameter, pass in `hidden=True`. Due to the assumption of required being the
  default state, `hidden=True` will overwrite the required state.

  The defintion above will lead to the following inputs for our custom node:

  ```python
  >> print(MyCustomNode.INPUT_TYPES)

  {
      'required': {
          'pos_prompt_text': ('STRING', {'multiline': True, 'default': 'masterpiece'}),
          'custom_weight': ('FLOAT', {'default': 1.0, 'min': 0.0, 'max': 1.0,
                                      'step': 0.1}),
      },
      'optional': {
          'neg_prompt_text': ('STRING', {'multiline': True, 'default': 'b&w'})
      },
      'hidden': {
          'super secret': ('FLOAT',)
      }
  }
  ```



  Output parameters are defined analogously to input parameters as fields. Check
  the list of available output types in the
  [documentation](/docs/README.md#output-types).

  Example:

  ```python
  from comfyui_types import ComfyUINode, StringOutput, FloatOutput

  class MyCustomNode(ComfyUINode):
      

      combined_prompt = StringOutput()
      calculated_score = FloatOutput(display_name='Final Score')
  ```

  Outputs are very straightforward to define, as they do not need any
  configuration. The name for the `RETURN_NAMES` list is taken from the variable
  name that you are assigning, i.e., `combined_prompt` in this example.
  Alternatively, you can override this in the same way as with input parameters by
  passing the optional `display_name` parameter to the definition. The example
  above would result in the following outputs:

  ```python
  RETURN_TYPES = ('STRING', 'FLOAT')
  RETURN_NAMES = ('combined_prompt', 'Final Score')
  ```



  We are providing some examples [here](/examples) to help you better understand,
  how to write your own custom nodes.



  Custom nodes can be manually exported as always like this:

  ```python
  NODE_CLASS_MAPPINGS = {
      'MyCustomNode': MyCustomNode,
  }
  NODE_DISPLAY_NAME_MAPPINGS = {
      'MyCustomNode': 'My Cool Custom Node',
  }

  __all__ = [NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS]
  ```

  However, there is a convenience function to help with this:

  ```python
  NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS = export_nodes([
      MyCustomNode,
  ])

  __all__ = [NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS]
  ```
  (The `__all__` is not strictly needed, but good practice.)

  This will automatically create the mapping tables according to the class name
  and optionally the `display_name` property. If no `display_name` is set, the
  class name is used.



  Internally, the `ComfyUINode` simply exports the parameters that you have
  defined with proper classes and types in such a way that ComfyUI can load them.
  That means for example that all your input parameters are collected and used to
  automatically create the `INPUT_TYPES` dictionary that ComfyUI will try to find
  in your node. For example, the input parameter

  ```python
  pos_prompt_text = StringInput(default='masterpiece', multiline=True)
  ```

  will automatically create the following entry in `INPUT_TYPES`:

  ```python
  ('STRING', {'default': 'masterpiece', 'multiline': True})
  ```



  The way the `ComfyUINode` is defined is fully compatible with existing nodes and
  practices. It simply creates the fields that are expected from a class that
  ComfyUI imports as a custom node, like `INPUT_TYPES`. If at any point, you do
  not like the conventions or they do not work with your use case, you can fall
  back to the regular way of defining custom nodes in ComfyUI, i.e.:

  - use `CATEGORY` instead of `category`
  - use `FUNCTION` instead of `function`
  - define your `INPUT_TYPES` or `RETURN_TYPES` as always

  Only the parts that you choose to use will actually be active, you can mix and
  match to suit your preferences.



  The following list of projects are using this project. This is not relevant to
  end-consumers, but if you are developing your own nodes, head over there and get
  some inspiration and real-world exposure:

  - [ComfyUI Claude](https://github.com/tkreuziger/comfyui-claude): A set of
  custom nodes that are using Anthropic's Claude models for describing images and
  transforming texts.

  If you want to add a project to this list, please open a PR!



  The project uses `tox` for development. You can get started like this:

  ```bash
  git clone https://github.com/tkreuziger/comfyui-types.git ./comfyui_types
  pip install -e ./comfyui_types
  ```

  Then you can run different parts of the pipeline:
  ```bash

  tox -e format


  tox -e lint


  tox -e build
  ```



  This code is provided under the terms of the GPL-3.0 license.



  Contributions of any kind (bug fixes, extensions, documentation etc.) are always
  welcome, simply open a PR!


