# packages

pkgId: 184ee03b4c481e73a29e63af6315c61eb6485069256afabf89acd2ee87dfb36d
name: python-cmbagent-help
arch: noarch
version: 0.0.1.post1
epoch: 0
release: 1
summary: Development documents and examples for cmbagent
url: https://github.com/CMBAgents/cmbagent
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cmbagent-0.0.1.post1-1.src.rpm
location_href: Packages/python-cmbagent-help-0.0.1.post1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cmbagent.svg)](https://pypi.org/project/cmbagent/)[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) [![Documentation Status](https://readthedocs.org/projects/cmbagent/badge/?version=latest)](https://cmbagent.readthedocs.io/en/latest/?badge=latest) [![arXiv](https://img.shields.io/badge/arXiv-2412.00431-b31b1b.svg)](https://arxiv.org/abs/2412.00431)


  Multi-agent system for data analysis, made by cosmologists, powered by [autogen](https://github.com/autogen-ai/autogen)/[ag2](https://github.com/ag2ai/ag2).

  > **Note:** This software is under MIT license. We bear no responsibility for any misuse of this software or its outputs.


  Our preliminary documentation and set of working examples can be consulted [here](https://cmbagent.readthedocs.io/en/latest/index.html).

  We emphasize that [cmbagent](https://github.com/CMBAgents/cmbagent) is under active development. We present our work-in-progress in [Laverick et al (2024)](https://arxiv.org/abs/2412.00431). If you would like to cite us, please use:

  ```bash
     @misc{Laverick:2024fyh,
        author = "Laverick, Andrew and Surrao, Kristen and Zubeldia, Inigo and Bolliet, Boris and Cranmer, Miles and Lewis, Antony and Sherwin, Blake and Lesgourgues, Julien",
        title = "{Multi-Agent System for Cosmological Parameter Analysis}",
        eprint = "2412.00431",
        archivePrefix = "arXiv",
        primaryClass = "astro-ph.IM",
        month = "11",
        year = "2024"
     }
  ```

  Our project is funded by the [Cambridge Centre for Data-Driven Discovery Accelerate Programme](https://science.ai.cam.ac.uk).




  If you plan to modify the code, follow these steps:

  Clone and install our package from `PyPi`:

  ```bash
  pip install cmbagent
  ```

  Before pip installing cmbagent, creating a virual environment is envouraged:
  ```bash
  python -m venv /path/to/your/envs/cmbagent_env
  source /path/to/your/envs/cmbagent_env/bin/activate
  ```
  You can then pip install cmbagent in this fresh environment.

  If you are a cosmologist, you need the RAG data to use `cmbagent` in your cosmology work.



  Do this:

  ```bash
  export CMBAGENT_DATA=/where/you/want/the/data
  ```

  Note that you need to set the `CMBAGENT_DATA` environment variable accordingly before using `cmbagent`
  in any future session. Maybe you want to add this to your `.bashrc` or `.zshrc` file, or in your `activate` script.




  RAG agents are defined in a generic way. The core of the code is located in [cmbagent.py](https://github.com/CMBAgents/cmbagent/blob/main/cmbagent/cmbagent.py).

  To generate a RAG agent, create a `.py` and `.yaml` file and place them in the [assistants directory](https://github.com/CMBAgents/cmbagent/tree/main/cmbagent/assistants). Additionally, create a directory named after the agent and include associated files in the [data directory](https://github.com/CMBAgents/cmbagent_data/tree/main/data) of cmbagent.

  Apart from the RAG agents, we have assistant agents (engineer and planner) and a code agent (executor).





  All agents inherit from the `BaseAgent` class. You can find the definition of `BaseAgent` in the [base_agent.py](https://github.com/CMBAgents/cmbagent/blob/main/cmbagent/base_agent.py) file.





  Before you can use cmbagent, you need to set your OpenAI API key as an environment variable:

  For Unix-based systems (Linux, macOS):
  ```bash
  export OPENAI_API_KEY="sk-..."
  ```
  (paste in your bashrc or zshrc file, if possible.)

  For Windows:
  ```cmd
  setx OPENAI_API_KEY "sk-..."
  ```

  You can also pass your API key to cmbagent as an argument when you instantiate it:

  ```python
  cmbagent = CMBAgent(llm_api_key="sk-...")
  ```

  Instantiate the CMBAgent with:

  ```python
  from cmbagent import CMBAgent
  cmbagent = CMBAgent(verbose=True)
  ```

  Define a task as:

  ```python
  task = """
         Get cosmological parameter values from Planck 2018 analysis of TT,TE,EE+lowE+lensing with the Plik likelihood in LCDM.
         Use Cobaya with Classy_SZ to evaluate the ACT DR6 lensing likelihood for sigma8=0.8 and Omega_m=0.31. Other parameters set to Planck 2018.
         To set Omega_m, adjust the value of omch2.
         Give me the value of log-likelihood.
         """
  ```

  Solve the task with:

  ```python
  cmbagent.solve(task)
  ```

  If you request any output, it will be saved in the [output directory](https://github.com/CMBAgents/cmbagent/tree/main/output).

  Show the plot with:

  ```python
  cmbagent.show_plot("cmb_tt_power_spectrum.png")
  ```

  Restore session with:

  ```python
  cmbagent.restore()
  ```

  Push vector stores of RAG agents into the OpenAI platform:

  ```python
  cmbagent = CMBAgent(make_vector_stores=True)
  ```

  Push selected vector stores of RAG agents into the OpenAI platform:

  ```python
  cmbagent = CMBAgent(make_vector_stores=['act', 'camb'])
  ```

  Start session with only a subset of RAG agents:

  ```python
  cmbagent = CMBAgent(agent_list=['classy', 'planck'])
  ```

  Show allowed transitions:

  ```python
  cmbagent.show_allowed_transitions()
  ```

  cmbagent uses cache to speed up the process and reduce costs when asking the same questions. When developing, it can be useful to clear the cache. Do this with:

  ```python
  cmbagent.clear_cache()
  ```


pkgId: f3fe7d37f7b8661fb328215381631e7c065cb64a009a430743a3a0e8d39412e9
name: python-cmd2-help
arch: noarch
version: 2.5.8
epoch: 0
release: 1
summary: Development documents and examples for cmd2
url: https://pypi.org/project/cmd2/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cmd2-2.5.8-1.src.rpm
location_href: Packages/python-cmd2-help-2.5.8-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">cmd2 : immersive interactive command line applications</h1>

  [![Latest Version](https://img.shields.io/pypi/v/cmd2.svg?style=flat-square&label=latest%20stable%20version)](https://pypi.python.org/pypi/cmd2/)
  [![GitHub Actions](https://github.com/python-cmd2/cmd2/workflows/CI/badge.svg)](https://github.com/python-cmd2/cmd2/actions?query=workflow%3ACI)
  [![codecov](https://codecov.io/gh/python-cmd2/cmd2/branch/master/graph/badge.svg)](https://codecov.io/gh/python-cmd2/cmd2)
  [![Documentation Status](https://readthedocs.org/projects/cmd2/badge/?version=latest)](http://cmd2.readthedocs.io/en/latest/?badge=latest)
  <a href="https://discord.gg/RpVG6tk"><img src="https://img.shields.io/badge/chat-on%20discord-7289da.svg" alt="Chat"></a>

  <p align="center">
    <a href="#the-developers-toolbox">Developer's Toolbox</a> •
    <a href="#philosophy">Philosophy</a> •
    <a href="#installation">Installation</a> •
    <a href="#documentation">Documentation</a> •
    <a href="#tutorials">Tutorials</a> •
    <a href="#hello-world">Hello World</a> •
    <a href="#projects-using-cmd2">Projects using cmd2</a> •
  </p>

  [![Screenshot](https://raw.githubusercontent.com/python-cmd2/cmd2/master/cmd2.png)](https://youtu.be/DDU_JH6cFsA)

  cmd2 is a tool for building interactive command line applications in Python. Its goal is to make it
  quick and easy for developers to build feature-rich and user-friendly interactive command line
  applications. It provides a simple API which is an extension of Python's built-in
  [cmd](https://docs.python.org/3/library/cmd.html) module. cmd2 provides a wealth of features on top
  of cmd to make your life easier and eliminates much of the boilerplate code which would be necessary
  when using cmd.



  ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)

  When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
  System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall.
  Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
  On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering functionality.
  The price we pay for beautifully colored displays is complexity required to aggregate disperate applications into larger systems.
  `cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart workflow automation systems.

  The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
  When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:

  - Tab Completion
  - Automation Transition



  <a href="https://imgflip.com/i/63h03x"><img src="https://i.imgflip.com/63h03x.jpg" title="made at imgflip.com" width="70%" height="%70"/></a>

  Deep extensive tab completion and help text generation based on the argparse library create the first pillar of 'ease of command discovery'. The following is a list of features in this category.

  - Great tab completion of commands, subcommands, file system paths, and shell commands.
  - Custom tab completion for user designed commands via simple function overloading.
  - Tab completion from `persistent_history_file` sources added with very little friction.
  - Automatic tab completion of `argparse` flags and optional arguments.
  - Path completion easily enabled.
  - When all else fails, custom tab completion based on `choices_provider` can fill any gaps.

  <a href="https://imgflip.com/i/66t0y0"><img src="https://i.imgflip.com/66t0y0.jpg" title="made at imgflip.com" width="70%" height="70%"/></a>

  cmd2 creates the second pillar of 'ease of transition to automation' through alias/macro creation, command line argument parsing and execution of cmd2 scripting.

  - Flexible alias and macro creation for quick abstraction of commands.
  - Text file scripting of your application with `run_script` (`@`) and `_relative_run_script` (`@@`)
  - Powerful and flexible built-in Python scripting of your application using the `run_pyscript` command
  - Transcripts for use with built-in regression can be automatically generated from `history -t` or `run_script -t`



  On all operating systems, the latest stable version of `cmd2` can be installed using pip:

  ```bash
  pip install -U cmd2
  ```

  cmd2 works with Python 3.8+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.

  For information on other installation options, see
  [Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
  documentation.



  The latest documentation for cmd2 can be read online here: https://cmd2.readthedocs.io/en/latest/

  It is available in HTML, PDF, and ePub formats.

  The best way to learn the cmd2 api is to delve into the example applications located in source under examples.



  - PyOhio 2019 presentation:
    - [video](https://www.youtube.com/watch?v=pebeWrTqIIw)
    - [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
    - [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)
  - [Cookiecutter](https://github.com/cookiecutter/cookiecutter) Templates from community
    - Basic cookiecutter template for cmd2 application : https://github.com/jayrod/cookiecutter-python-cmd2
    - Advanced cookiecutter template with external plugin support : https://github.com/jayrod/cookiecutter-python-cmd2-ext-plug
  - [Example Applications](https://github.com/jayrod/cmd2-example-apps)



  ```python

  """A simple cmd2 application."""
  import cmd2


  class FirstApp(cmd2.Cmd):
      """A simple cmd2 application."""

    def do_hello_world(self, _: cmd2.Statement):
      self.poutput('Hello World')

  if __name__ == '__main__':
      import sys
      c = FirstApp()
      sys.exit(c.cmdloop())

  ```



  If you think you've found a bug, please first read through the open [Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead and create a new GitHub issue. Be sure to include as much information as possible so we can reproduce the bug. At a minimum, please state the following:

  - `cmd2` version
  - Python version
  - OS name and version
  - What you did to cause the bug to occur
  - Include any traceback or error message associated with the bug



  | Application Name                                                | Description                                                                                                                     | Organization or Author                                                |
  | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
  | [CephFS Shell](https://github.com/ceph/ceph)                    | The Ceph File System, or CephFS, is a POSIX-compliant file system built on top of Ceph’s distributed object store               | [ceph](https://ceph.com/)                                             |
  | [garak](https://github.com/NVIDIA/garak)                        | LLM vulnerability scanner that checks if an LLM can be made to fail in a way we don't want                                      | [NVIDIA](https://github.com/NVIDIA)                                   |
  | [medusa](https://github.com/Ch0pin/medusa)                      | Binary instrumentation framework that that automates processes for the dynamic analysis of Android and iOS Applications         | [Ch0pin](https://github.com/Ch0pin)                                   |
  | [InternalBlue](https://github.com/seemoo-lab/internalblue)      | Bluetooth experimentation framework for Broadcom and Cypress chips                                                              | [Secure Mobile Networking Lab](https://github.com/seemoo-lab)         |
  | [SCCMHunter](https://github.com/garrettfoster13/sccmhunter)     | A post-ex tool built to streamline identifying, profiling, and attacking SCCM related assets in an Active Directory domain      | [Garret Foster](https://github.com/garrettfoster13)                   |
  | [Unipacker](https://github.com/unipacker/unipacker)             | Automatic and platform-independent unpacker for Windows binaries based on emulation                                             | [unipacker](https://github.com/unipacker)                             |
  | [Frankenstein](https://github.com/seemoo-lab/frankenstein)      | Broadcom and Cypress firmware emulation for fuzzing and further full-stack debugging                                            | [Secure Mobile Networking Lab](https://github.com/seemoo-lab)         |
  | [Poseidon](https://github.com/faucetsdn/poseidon)               | Leverages software-defined networks (SDNs) to acquire and then feed network traffic to a number of machine learning techniques. | [Faucet SDN](https://github.com/faucetsdn)                            |
  | [DFTimewolf](https://github.com/log2timeline/dftimewolf)        | A framework for orchestrating forensic collection, processing and data export                                                   | [log2timeline](https://github.com/log2timeline)                       |
  | [GAP SDK](https://github.com/GreenWaves-Technologies/gap_sdk)   | SDK for Greenwaves Technologies' GAP8 IoT Application Processor                                                                 | [GreenWaves Technologies](https://github.com/GreenWaves-Technologies) |
  | [REW Sploit](https://github.com/REW-sploit/REW-sploit)          | Emulate and Dissect Metasploit Framework (MSF) and other attacks                                                                | [REW-sploit](https://github.com/REW-sploit)                           |
  | [tomcatmanager](https://github.com/tomcatmanager/tomcatmanager) | A command line tool and python library for managing a tomcat server                                                             | [tomcatmanager](https://github.com/tomcatmanager)                     |
  | [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                 | [CrowdStrike](https://github.com/CrowdStrike)                         |
  | [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                  | [expliot_framework](https://gitlab.com/expliot_framework/)            |

  Possibly defunct but still good examples

  | Application Name                                                              | Description                                                                            | Organization or Author                                         |
  | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
  | [Katana](https://github.com/JohnHammond/katana)                               | Automatic CTF Challenge Solver                                                         | [John Hammond](https://github.com/JohnHammond)                 |
  | [SatanSword](https://github.com/Lucifer1993/SatanSword) (in Chinese)          | Comprehensive Penetration Framework for Red Teaming                                    | [Lucifer1993](https://github.com/Lucifer1993)                  |
  | [Jok3r](http://www.jok3r-framework.com)                                       | Network & Web Pentest Automation Framework                                             | [Koutto](https://github.com/koutto)                            |
  | [Counterfit](https://github.com/Azure/counterfit)                             | a CLI that provides a generic automation layer for assessing the security of ML models | [Microsoft Azure](https://github.com/Azure)                    |
  | [Overlord](https://github.com/qsecure-labs/overlord)                          | Red Teaming Infrastructure Automation                                                  | [QSecure Labs](https://github.com/qsecure-labs)                |
  | [Automated Reconnaissance Pipeline](https://github.com/epi052/recon-pipeline) | An automated target reconnaissance pipeline                                            | [epi052](https://github.com/epi052)                            |
  | [JSShell](https://github.com/Den1al/JSShell)                                  | An interactive multi-user web JavaScript (JS) shell                                    | [Den1al](https://github.com/Den1al)                            |
  | [RedShell](https://github.com/Verizon/redshell)                               | An interactive command prompt for red teaming and pentesting                           | [Verizon](https://github.com/Verizon)                          |
  | [FLASHMINGO](https://github.com/mandiant/flashmingo)                          | Automatic analysis of SWF files based on some heuristics. Extensible via plugins.      | [Mandiant](https://github.com/mandiant)                        |
  | [psiTurk](https://github.com/NYUCCL/psiTurk)                                  | An open platform for science on Amazon Mechanical Turk                                 | [NYU Computation and Cognition Lab](https://github.com/NYUCCL) |

  Note: If you have created an application based on `cmd2` that you would like us to mention here, please get in touch.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2008-2024 Catherine Devlin and others  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: 9949f1d17f4c7bdca6dc1f2af3281b1fe5ee8eb95b968e9f82733ab70ad35ae8
name: python-cmdbox-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for cmdbox
url: https://github.com/hamacom2004jp/cmdbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cmdbox-0.2.1-1.src.rpm
location_href: Packages/python-cmdbox-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  - プラグイン機構を備えたコマンドラインアプリケーションです。
  - ドキュメントは[こちら](https://hamacom2004jp.github.io/cmdbox/)。
  - cmdboxを使用することで、複雑なオプションを持つコマンドを簡単に実装できます。
  - 実装したコマンドは、RESTAPIとしても呼び出せるようになります。
  - 実装したコマンドは、redisを介してリモートサーバーで実行することが出来ます。
  - 実装したコマンドは、Webコンソールから実行できます。
  - リモートサーバーでコマンドを実行するために、必要なファイルをwebファイラーを使って転送できます。




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


pkgId: f11d51ef27b7958031cf9ed86def73c8b82310d3ee1ec2551e2bf9675676020a
name: python-cmem-cmemc-help
arch: noarch
version: 24.2.0
epoch: 0
release: 1
summary: Development documents and examples for cmem-cmemc
url: https://eccenca.com/go/cmemc
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cmem-cmemc-24.2.0-1.src.rpm
location_href: Packages/python-cmem-cmemc-help-24.2.0-1.noarch.rpm
checksum_type: sha256
description:
  cmemc is the official command line client for [eccenca Corporate Memory](https://documentation.eccenca.com/).

  [![version][version-shield]][changelog] [![Python Versions][python-shield]][pypi] [![eccenca Corporate Memory][cmem-shield]][cmem]

  [![teaser][teaser-image]][cmemc-docu]



  In order to install the cmemc, run:

      pipx install cmem-cmemc

  Of course you can install cmemc also with pip, but we recommend [pipx](https://pypa.github.io/pipx/) for normal desktop usage.



  cmemc is intended for System Administrators and Linked Data Expert, who wants to automate and remote control activities on eccenca Corporate Memory.

  The cmemc manual including basic usage pattern, configuration as well as a command reference is available at:

  [https://eccenca.com/go/cmemc](https://eccenca.com/go/cmemc)

  cmemc only works with Python 3 and refuses to work with Python 2.x.
  In addition to that, cmemc will warn you in case an untested Python environment is used.


  [version-shield]: https://badge.fury.io/py/cmem-cmemc.svg
  [changelog]: https://pypi.org/project/cmem-cmemc/#history
  [python-shield]: https://img.shields.io/pypi/pyversions/cmem-cmemc.svg
  [pypi]: https://pypi.org/project/cmem-cmemc/
  [cmem]: https://documentation.eccenca.com
  [cmem-shield]: https://img.shields.io/badge/made%20for-eccenca%20Corporate%20Memory-blue?logo=data:image/svg%2bxml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+CjxzdmcKICAgaWQ9IkxheWVyXzEiCiAgIGRhdGEtbmFtZT0iTGF5ZXIgMSIKICAgdmlld0JveD0iMCAwIDgxLjI5MDAwMSA4Mi4yODk4NiIKICAgdmVyc2lvbj0iMS4xIgogICB3aWR0aD0iODEuMjkwMDAxIgogICBoZWlnaHQ9IjgyLjI4OTg2NCIKICAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogICB4bWxuczpzdmc9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZGVmcwogICAgIGlkPSJkZWZzODI2Ij4KICAgIDxzdHlsZQogICAgICAgaWQ9InN0eWxlODI0Ij4KICAgICAgLmNscy0xIHsKICAgICAgICBmaWxsOiAjZjM5MjAwOwogICAgICB9CgogICAgICAuY2xzLTIgewogICAgICAgIGZpbGw6IG5vbmU7CiAgICAgICAgc3Ryb2tlOiAjZjM5MjAwOwogICAgICAgIHN0cm9rZS13aWR0aDogMS41cHg7CiAgICAgIH0KICAgIDwvc3R5bGU+CiAgPC9kZWZzPgogIDxnCiAgICAgaWQ9Imc4NDAiCiAgICAgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTMwLjc2LC0zMS4xNDAxMzkpIj4KICAgIDxwYXRoCiAgICAgICBjbGFzcz0iY2xzLTEiCiAgICAgICBkPSJNIDU1LjksODUuMTkgQSAyMC4xNCwyMC4xNCAwIDEgMCAzNS43Niw2NS4wNSAyMC4xNCwyMC4xNCAwIDAgMCA1NS45LDg1LjE5IFoiCiAgICAgICBpZD0icGF0aDgyOCIgLz4KICAgIDxwYXRoCiAgICAgICBjbGFzcz0iY2xzLTEiCiAgICAgICBkPSJtIDk4LDU0LjE0IGEgOSw5IDAgMSAwIC04Ljk1LC05IDguOTUsOC45NSAwIDAgMCA4Ljk1LDkgeiIKICAgICAgIGlkPSJwYXRoODMwIiAvPgogICAgPHBhdGgKICAgICAgIGNsYXNzPSJjbHMtMSIKICAgICAgIGQ9Ik0gODguMzUsMTA4LjQzIEEgMTIuMzEsMTIuMzEgMCAxIDAgNzYsOTYuMTIgMTIuMzEsMTIuMzEgMCAwIDAgODguMzEsMTA4LjQzIFoiCiAgICAgICBpZD0icGF0aDgzMiIgLz4KICAgIDxsaW5lCiAgICAgICBjbGFzcz0iY2xzLTIiCiAgICAgICB4MT0iODYuOTcwMDAxIgogICAgICAgeTE9IjkyLjA1OTk5OCIKICAgICAgIHgyPSI1OC43Nzk5OTkiCiAgICAgICB5Mj0iNjcuMzYwMDAxIgogICAgICAgaWQ9ImxpbmU4MzQiIC8+CiAgICA8bGluZQogICAgICAgY2xhc3M9ImNscy0yIgogICAgICAgeDE9Ijk5LjE4IgogICAgICAgeTE9IjQ1Ljg0IgogICAgICAgeDI9IjU1LjQ4IgogICAgICAgeTI9IjY2LjEyMDAwMyIKICAgICAgIGlkPSJsaW5lODM2IiAvPgogICAgPGxpbmUKICAgICAgIGNsYXNzPSJjbHMtMiIKICAgICAgIHgxPSI5Ny45ODk5OTgiCiAgICAgICB5MT0iNDQuNjUwMDAyIgogICAgICAgeDI9Ijg4LjM0OTk5OCIKICAgICAgIHkyPSI5Mi44Mzk5OTYiCiAgICAgICBpZD0ibGluZTgzOCIgLz4KICA8L2c+Cjwvc3ZnPgo=
  [teaser-image]: https://documentation.eccenca.com/24.1/automate/cmemc-command-line-interface/configuration/completion-setup/22.1-cmemc-create-dataset.gif
  [cmemc-docu]: https://eccenca.com/go/cmemc


pkgId: 44b2cbe0a0f0ef35ec4fd746c7878aa575a221ee3685e6df271dc33b9ffe3a17
name: python-cmi-docx-help
arch: noarch
version: 0.3.6
epoch: 0
release: 1
summary: Development documents and examples for cmi-docx
url: https://pypi.org/project/cmi-docx/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cmi-docx-0.3.6-1.src.rpm
location_href: Packages/python-cmi-docx-help-0.3.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/childmindresearch/cmi-docx/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/childmindresearch/cmi-docx/actions/workflows/test.yaml?query=branch%3Amain)
  [![codecov](https://codecov.io/gh/childmindresearch/cmi-docx/branch/main/graph/badge.svg?token=22HWWFWPW5)](https://codecov.io/gh/childmindresearch/cmi-docx)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  ![stability-stable](https://img.shields.io/badge/stability-stable-green.svg)
  [![LGPL--2.1 License](https://img.shields.io/badge/license-LGPL--2.1-blue.svg)](https://github.com/childmindresearch/cmi-docx/blob/main/LICENSE)
  [![pages](https://img.shields.io/badge/api-docs-blue)](https://childmindresearch.github.io/cmi-docx)

  `cmi-docx` is a Python library for manipulating .docx files built on top of `python-docx`. It extends the functionality of `python-docx` by providing additional features and utilities for working with .docx files.



  - Find and replace.
  - Insert paragraphs in the middle of a document.
  - Manipulate styles and formatting of paragraphs' substrings.



  Install this package from pypi using your favorite package manager. For example, using `pip`:

  ```sh
  pip install cmi-docx
  ```



  The following example demonstratesa few features of cmi-docx:

  ```Python
  import docx

  from cmi_docx import document

  doc = docx.Document()
  paragraph = doc.add_paragraph("Hello, world!")
  extend_document = document.ExtendDocument(doc)
  extend_paragraph = document.ExtendParagraph(paragraph)


  extend_document.replace("Hello", "Hi", {"bold": True})


  extend_document.insert_image(index=1, image_path="path/to/image.png")


  extend_paragraph.format(italics=True)
  ```


pkgId: e6619d944aeb26ad8f013d61bf6b68b5e9c2115da4f5433182dae78bc07173e4
name: python-cnlunar-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for cnlunar
url: https://github.com/OPN48/cnLunar
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cnlunar-0.1.8-1.src.rpm
location_href: Packages/python-cnlunar-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
      import datetime

      import cnlunar

      

      a = cnlunar.Lunar(datetime.datetime(2022, 11, 14, 10, 30), godType='8char')  # 常规算法
      

      '日期': a.date,

      '农历数字': (a.lunarYear, a.lunarMonth, a.lunarDay, '闰' if a.isLunarLeapMonth else ''),

      '农历': '%s %s[%s]年 %s%s' % (a.lunarYearCn, a.year8Char, a.chineseYearZodiac, a.lunarMonthCn, a.lunarDayCn),

      '星期': a.weekDayCn,

      

      '今日节日': (a.get_legalHolidays(), a.get_otherHolidays(), a.get_otherLunarHolidays()),

      '八字': ' '.join([a.year8Char, a.month8Char, a.day8Char, a.twohour8Char]),

      '今日节气': a.todaySolarTerms,

      '下一节气': (a.nextSolarTerm, a.nextSolarTermDate, a.nextSolarTermYear),

      '今年节气表': a.thisYearSolarTermsDic,

      '季节': a.lunarSeason,

      '今日时辰': a.twohour8CharList,

      '时辰凶吉': a.get_twohourLuckyList(),

      '生肖冲煞': a.chineseZodiacClash,

      '星座': a.starZodiac,

      '星次': a.todayEastZodiac,

      '彭祖百忌': a.get_pengTaboo(),

      '彭祖百忌精简': a.get_pengTaboo(long=4, delimit='<br>'),

      '十二神': a.get_today12DayOfficer(),

      '廿八宿': a.get_the28Stars(),

      '今日三合': a.zodiacMark3List,

      '今日六合': a.zodiacMark6,

      '今日五行': a.get_today5Elements(),

      '纳音': a.get_nayin(),

      '九宫飞星': a.get_the9FlyStar(),

      '吉神方位': a.get_luckyGodsDirection(),

      '今日胎神': a.get_fetalGod(),

      '神煞宜忌': a.angelDemon,

      '今日吉神': a.goodGodName,

      '今日凶煞': a.badGodName,

      '宜': a.goodThing,

      '忌': a.badThing,

      '时辰经络': a.meridians

  八字月柱与八字日柱算神煞版本

  日期 	:	 2021-02-07 10:30:00

  农历数字 :	 (2020, 12, 26, '')

  农历 	:	 二零二零 庚子[鼠]年 腊月大廿六

  星期 	:	 星期日

  今日节日 :	 ('', '京汉铁路罢工纪念', '')

  八字 	:	 庚子 庚寅 丙戌 癸巳

  今日节气 :	 无

  下一节气 :	 ('雨水', (2, 18), 2021)

  今年节气表 :	 {'小寒': (1, 5), '大寒': (1, 20), '立春': (2, 3), '雨水': (2, 18), '惊蛰': (3, 5), '春分': (3, 20), '清明': (4, 4), '谷雨': (4, 20), '立夏': (5, 5), '小满': (5, 21), '芒种': (6, 5), '夏至': (6, 21), '小暑': (7, 7), '大暑': (7, 22), '立秋': (8, 7), '处暑': (8, 23), '白露': (9, 7), '秋分': (9, 23), '寒露': (10, 8), '霜降': (10, 23), '立冬': (11, 7), '小雪': (11, 22), '大雪': (12, 7), '冬至': (12, 21)}

  季节 	:	 孟春

  今日时辰 :	 ['戊子', '己丑', '庚寅', '辛卯', '壬辰', '癸巳', '甲午', '乙未', '丙申', '丁酉', '戊戌', '己亥', '庚子']

  时辰凶吉 :	 ['凶', '凶', '吉', '凶', '吉', '吉', '凶', '凶', '吉', '吉', '凶', '吉', '凶']

  生肖冲煞 :	 狗日冲龙

  星座 	:	 水瓶座

  星次 	:	 娵訾

  彭祖百忌 :	 丙不修灶 必见灾殃,戌不吃犬 作怪上床

  彭祖百忌精简 :	 丙不修灶<br>戌不吃犬

  十二神 	:	 ('成', '司命', '黄道日')

  廿八宿 	:	 星日马

  今日三合 :	 ['虎', '马']

  今日六合 :	 兔

  今日五行 :	 ['天干', '丙', '属火', '地支', '戌', '属土', '纳音', '土', '属土', '廿八宿', '星', '宿', '十二神', '成', '日']

  纳音 	:	 屋上土

  九宫飞星 :	 279135684

  吉神方位 :	 ['喜神西南', '财神西南', '福神西北', '阳贵正西', '阴贵西北']

  今日胎神 :	 厨灶栖外西北

  神煞宜忌 :	 ((['月德', '三合', '四相', '天喜', '月恩', '天官'], ['月厌', '神号', '伏兵', '地火', '受死', '飞廉', '大煞', '四击', '宝日']), (['祭祀', '出行', '结婚姻', '宴会', '嫁娶', '修造', '求医疗病', '上表章', '上官', '入学', '进人口', '竖柱上梁', '经络', '开市', '纳财', '安碓硙', '栽种', '牧养', '安葬', '选将', '求嗣', '酝酿', '临政', '庆赐', '安抚边境', '解除', '筑堤防', '祈福', '出师', '纳采', '纳畜', '营建', '立券交易', '缮城郭', '修宫室', '恤孤茕', '覃恩', '裁制', '开仓', '修仓库', '上册', '雪冤', '搬移'], ['剃头', '冠带', '修置产室', '开渠', '穿井', '平治道涂', '破屋坏垣', '伐木', '畋猎', '破土', '启攒', '布政事', '修饰垣墙', '整手足甲', '远回', '整容', '补垣', '取鱼', '鼓铸', '塞穴']))

  今日吉神 :	 ['月德', '三合', '四相', '天喜', '月恩', '天官']

  今日凶煞 :	 ['月厌', '神号', '伏兵', '地火', '受死', '飞廉', '大煞', '四击', '宝日']

  宜忌等第 :	 中：吉不抵凶，遇德从宜不从忌，不遇从忌不从宜。

  宜 		:	 ['祭祀', '出行', '结婚姻', '宴会', '嫁娶', '修造', '求医疗病', '上表章', '上官', '入学', '进人口', '竖柱上梁', '经络', '开市', '纳财', '安碓硙', '栽种', '牧养', '安葬', '选将', '求嗣', '酝酿', '临政', '庆赐', '安抚边境', '解除', '筑堤防', '祈福', '出师', '纳采', '纳畜', '营建', '立券交易', '缮城郭', '修宫室', '恤孤茕', '覃恩', '裁制', '开仓', '修仓库', '上册', '雪冤', '搬移']

  忌 		:	 ['剃头', '冠带', '修置产室', '开渠', '穿井', '平治道涂', '破屋坏垣', '伐木', '畋猎', '破土', '启攒', '布政事', '修饰垣墙', '整手足甲', '远回', '整容', '补垣', '取鱼', '鼓铸', '塞穴']

  时辰经络 :	 脾


pkgId: a82ece8cb45b19dc8a5418f99e4997008ffb1a14c648cc4ff18923ebf651e4c5
name: python-cnn-methods-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for cnn-methods
url: https://pypi.org/project/cnn-methods/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cnn-methods-1.0.3-1.src.rpm
location_href: Packages/python-cnn-methods-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  <img width="100%" src="https://kajabi-storefronts-production.kajabi-cdn.com/kajabi-storefronts-production/file-uploads/blogs/22606/images/f8d6362-3e5e-c73-a7a4-e54525b5431a_banner-yolov8.png" alt="YOLO Vision banner"></a>
  <br><br>
  <img width="100%" src="https://github.com/rorro6787/rorro6787/blob/main/Images/sam.jpg" alt="SAM"></a>

  This project explores the application of advanced computer vision techniques for fruit classification and segmentation. A custom Convolutional Neural Network (CNN) was designed and implemented to classify different types of fruits, focusing on achieving high accuracy with an efficient architecture. The CNN was trained on a labeled dataset of fruit images, utilizing techniques such as data augmentation and optimization strategies to enhance performance and robustness.

  Additionally, the project integrates a YOLO (You Only Look Once) model for real-time object detection and leverages the combination of YOLO and SAM (Segment Anything Model) for instance segmentation. This enables precise identification and segmentation of individual fruit instances, including segmentation with bounding boxes for more detailed analysis. The combination of custom and pre-trained models demonstrates versatility and effectiveness across multiple computer vision tasks.


  - [Requirements](#requirements)
  - [Installation and Usage](#installation-and-usage)
  - [Contributors](#contributors)
  - [Contributing](#contributing)


  - Python 3.X.X


  Read the library's documentation where it is explained how to download and use the different feautures it provides: [Official Documentation](https://rorro6787.github.io/CNN-YOLO-SAM-segmentation/)


  - [![GitHub](https://img.shields.io/badge/GitHub-100000?style=flat&logo=github&logoColor=white)](https://github.com/rorro6787) [![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=flat&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/emilio-rodrigo-carreira-villalta-2a62aa250/) **Emilio Rodrigo Carreira Villalta**


  Contributions are welcome! Please follow these steps:

  1. Fork the repository
  2. Create a new branch (`git checkout -b feature-branch`)
  3. Commit your changes (`git commit -m 'Add new feature'`)
  4. Push to the branch (`git push origin feature-branch`)
  5. Create a new Pull Request


pkgId: 1f6572b05a228f4bd87995e65640295d62a34d5051c3960e29429792120f4263
name: python-cnpip-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for cnpip
url: https://github.com/caoergou/cnpip
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cnpip-1.2.0-1.src.rpm
location_href: Packages/python-cnpip-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ustc         135.71       https://pypi.mirrors.ustc.edu.cn/simple
  aliyun       300.77       https://mirrors.aliyun.com/pypi/simple
  tuna         499.51       https://pypi.tuna.tsinghua.edu.cn/simple
  default      1252.75      https://pypi.org/simple
  tencent      1253.07      https://mirrors.cloud.tencent.com/pypi/simple
  ```

  ```bash
  cnpip set
  ```
  示例输出：
  ```
  未指定镜像源，自动选择最快的镜像源: ustc
  成功设置 pip 镜像源为 'https://pypi.mirrors.ustc.edu.cn/simple'
  ```

  ```bash
  cnpip set <镜像名称>
  ```
  示例：
  ```bash
  cnpip set tuna
  ```
  输出：
  ```
  成功设置 pip 镜像源为 'https://pypi.tuna.tsinghua.edu.cn/simple'
  ```

  ```bash
  cnpip unset
  ```
  输出：
  ```
  成功取消 pip 镜像源设置，已恢复为默认源。
  ```

  `cnpip` 会修改或创建 `pip` 的配置文件来设置镜像源：
  - **Linux/macOS**: `~/.pip/pip.conf`
  - **Windows**: `%APPDATA%\pip\pip.ini`
  在设置镜像源时，`cnpip` 只会修改或添加 `index-url` 配置，不会覆盖其他配置项。


  某些镜像源（如豆瓣）可能由于网络问题或镜像源本身的原因无法连接。在这种情况下，`cnpip` 会显示“无法连接”，并将其排在速度测试结果的最后。

  使用 `unset` 命令恢复为默认的 `pip` 镜像源：
  ```bash
  cnpip unset
  ```

  不会。`cnpip` 只会修改或添加 `index-url` 配置项，其他配置项会被保留。


pkgId: 178fb64123f972a0c9d7ab6ba8f9569e9374fb5e3a6c245ea81f34bfc6a7c4fd
name: python-co-op-translator-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for co-op-translator
url: https://github.com/Azure/co-op-translator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-co-op-translator-0.6.2-1.src.rpm
location_href: Packages/python-co-op-translator-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Logo](/imgs/logo.png)



  _Easily generate multilingual translations for your project with a single command, powered by Azure AI Services._

  [![Python package](https://img.shields.io/pypi/v/co-op-translator?color=4BA3FF)](https://pypi.org/project/co-op-translator/)
  [![License: MIT](https://img.shields.io/github/license/azure/co-op-translator?color=4BA3FF)](https://github.com/azure/co-op-translator/blob/main/LICENSE)
  [![Downloads](https://static.pepy.tech/badge/co-op-translator)](https://pepy.tech/project/co-op-translator)
  [![Downloads](https://static.pepy.tech/badge/co-op-translator/month)](https://pepy.tech/project/co-op-translator)

  [![GitHub contributors](https://img.shields.io/github/contributors/azure/co-op-translator.svg)](https://GitHub.com/azure/co-op-translator/graphs/contributors/)
  [![GitHub issues](https://img.shields.io/github/issues/azure/co-op-translator.svg)](https://GitHub.com/azure/co-op-translator/issues/)
  [![GitHub pull-requests](https://img.shields.io/github/issues-pr/azure/co-op-translator.svg)](https://GitHub.com/azure/co-op-translator/pulls/)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)

  [![GitHub watchers](https://img.shields.io/github/watchers/azure/co-op-translator.svg?style=social&label=Watch)](https://GitHub.com/azure/co-op-translator/watchers/)
  [![GitHub forks](https://img.shields.io/github/forks/azure/co-op-translator.svg?style=social&label=Fork)](https://GitHub.com/azure/co-op-translator/network/)
  [![GitHub stars](https://img.shields.io/github/stars/azure/co-op-translator?style=social&label=Star)](https://GitHub.com/azure/co-op-translator/stargazers/)

  [![Open in GitHub Codespaces](https://img.shields.io/static/v1?style=for-the-badge&label=Github%20Codespaces&message=Open&color=24292F&logo=github)](https://codespaces.new/azure/co-op-translator)
  [![Open in Dev Containers](https://img.shields.io/static/v1?style=for-the-badge&label=VS%20Code%20Dev%20Containers&message=Open&color=007ACC&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/azure/co-op-translator)



  | Type                  | Name                           |
  |-----------------------|--------------------------------|
  | Language Model        | ![Azure OpenAI](https://img.shields.io/badge/Azure_OpenAI-blue?style=flat-square) ![OpenAI](https://img.shields.io/badge/OpenAI-green?style=flat-square&logo=openai) |
  | Computer Vision       | ![Azure Computer Vision](https://img.shields.io/badge/Azure_Computer_Vision-blue?style=flat-square) |

  > [!NOTE]
  > If a computer vision service is not available, the co-op translator will switch to [Markdown-only mode](./getting_started/markdown-only-mode.md).



  **Co-op Translator** is a Python package designed to automate multilingual translations for your projects using advanced Large Language Model (LLM) technology and Azure AI Services. This project aims to simplify the process of translating content into multiple languages, making it accessible and efficient for developers.

  By integrating Co-op Translator into your workflow, you can automatically generate organized translation folders for different languages, and translate both Markdown files and images effortlessly.

  Here is an example of how Co-op Translator structures the translations and translates both Markdown files and text within images in your project:

  ![Example](/imgs/translation-ex.png)

  **Ready to unlock multilingual accessibility? Get started with Co-op Translator today!**



  - **Automated Translations**: Translate text into multiple languages effortlessly.
  - **Markdown Preservation**: Maintain correct Markdown syntax during translation.
  - **Image Text Translation**: Extract and translate text within images.
  - **Advanced LLM Technology**: Utilize cutting-edge language models for high-quality translations.
  - **Easy Integration**: Seamlessly integrate with your existing project setup.
  - **Simplify Localization**: Streamline the process of localizing your project for international markets.



  English is often considered the universal language of technology, but many developers worldwide are non-native English speakers. This can create barriers in accessing and contributing to technical projects.

  **Co-op Translator** aims to break down these language barriers by providing an easy-to-use tool for automating translations. By making technical documentation accessible in multiple languages, we empower developers, students, and researchers globally.



  Join us in revolutionizing global communication! Give a ⭐ to [Co-op Translator](https://github.com/azure/co-op-translator) on GitHub and help us break down language barriers together. Your support makes a difference!



  ![Architecture](/imgs/architecture_241019.png)

  The process begins with Markdown and image files from your project folder, which are processed by various AI services:

  - **Language Models**:
    - **Azure OpenAI** and other supported LLMs translate text from Markdown files. See the [supported models and services](#-supported-models-and-services) for more information.
  - **Computer Vision Services** (optional):
    - **Azure Computer Vision** extracts text from images, which are then translated by the selected language model. If a computer vision service is not available, the process defaults to [Markdown-only mode](./getting_started/markdown-only-mode.md).

  The final translated Markdown and image files are saved in the designated translation folder, ready to be used in multiple languages.





  - **Python 3.10 or higher**: Required for running the Co-op Translator.
  - **Language Model Resource**:
    - **Azure OpenAI** or other LLMs. Details can be found in the [supported models and services](#-supported-models-and-services).
  - **Computer Vision Resource** (optional):
    - For image translation. If unavailable, the translator defaults to [Markdown-only mode](./getting_started/markdown-only-mode.md).
    - **Azure Computer Vision**





  ```bash
  pip install co-op-translator
  ```



  ```bash
  poetry add co-op-translator
  ```



  > [!NOTE]
  > While this tutorial focuses on Azure resources, you can use any supported language model from the [supported models and services](#-supported-models-and-services) list.

  1. Set up resources
     - [Set up Azure OpenAI](./getting_started/set-up-resources/set-up-azure-openai.md)
     - [Set up Azure Computer Vision](./getting_started/set-up-resources/set-up-azure-computer-vision.md) (optional)

  2. [Create an '.env' file in the root directory](./getting_started/create-env-file.md)
     - Include necessary keys for the chosen language model service.
     - If Azure Computer Vision keys are omitted or `-md` is specified, the translator will operate in Markdown-only mode.
  3. [Install the Co-op translator package](./getting_started/install-package.md)
  4. [Translate your project using Co-op Translator](./getting_started/translator-your-project.md)



  - [Command reference](./getting_started/command-reference.md): Learn about all available commands and their options in detail.
  - [Multi-language support setup](./getting_started/multi-language-support.md): Before starting the translation process, you can add a table in the README that links to the translated versions of your document.
  - [Supported Languages](./getting_started/supported-languages.md): Check the list of supported languages and instructions to add new languages.
  - [Markdown-Only Mode](./getting_started/markdown-only-mode.md): Learn how to use Co-op Translator in Markdown-only mode.



  These case studies show how Co-op Translator was applied to translate a real-world project. It highlights the translation process, the challenges encountered, and the results achieved, providing a useful reference for applying the tool to similar projects.

  1. [Phi-3 Cookbook translation: A case study](./getting_started/Phi-3Cookbook-translation-case.md)



  Learn more about Co-op Translator through our presentations _(Click the image below to watch on YouTube.)_:

  - **Open at Microsoft**: A brief 18-minute introduction and quick guide on how to use Co-op Translator.

    [![Open at Microsoft](/imgs/open-ms-thumbnail.jpg)](https://www.youtube.com/watch?v=jX_swfH_KNU)

  - **Microsoft Reactor**: A one-hour detailed step-by-step guide covering everything from understanding what Co-op Translator is, setting up the tool, and using it effectively, to a live demo showcasing its capabilities in action.

    [![Microsoft Reactor](/imgs/reactor-thumbnail.jpg)](https://www.youtube.com/watch?v=boTtKVPBLAc)



  This project welcomes contributions and suggestions. Interested in contributing to Azure Co-op Translator? Please see our [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines on how you can help make Co-op Translator more accessible.



  [![co-op-translator contributors](https://contrib.rocks/image?repo=Azure/co-op-translator)](https://github.com/Azure/co-op-translator/graphs/contributors)



  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.



  Microsoft is committed to helping our customers use our AI products responsibly, sharing our learnings, and building trust-based partnerships through tools like Transparency Notes and Impact Assessments. Many of these resources can be found at [https://aka.ms/RAI](https://aka.ms/RAI).
  Microsoft’s approach to responsible AI is grounded in our AI principles of fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability.

  Large-scale natural language, image, and speech models - like the ones used in this sample - can potentially behave in ways that are unfair, unreliable, or offensive, in turn causing harms. Please consult the [Azure OpenAI service Transparency note](https://learn.microsoft.com/legal/cognitive-services/openai/transparency-note?tabs=text) to be informed about risks and limitations.

  The recommended approach to mitigating these risks is to include a safety system in your architecture that can detect and prevent harmful behavior. [Azure AI Content Safety](https://learn.microsoft.com/azure/ai-services/content-safety/overview) provides an independent layer of protection, able to detect harmful user-generated and AI-generated content in applications and services. Azure AI Content Safety includes text and image APIs that allow you to detect material that is harmful. We also have an interactive Content Safety Studio that allows you to view, explore and try out sample code for detecting harmful content across different modalities. The following [quickstart documentation](https://learn.microsoft.com/azure/ai-services/content-safety/quickstart-text?tabs=visual-studio%2Clinux&pivots=programming-language-rest) guides you through making requests to the service.

  Another aspect to take into account is the overall application performance. With multi-modal and multi-models applications, we consider performance to mean that the system performs as you and your users expect, including not generating harmful outputs. It's important to assess the performance of your overall application using [generation quality and risk and safety metrics](https://learn.microsoft.com/azure/ai-studio/concepts/evaluation-metrics-built-in).

  You can evaluate your AI application in your development environment using the [prompt flow SDK](https://microsoft.github.io/promptflow/index.html). Given either a test dataset or a target, your generative AI application generations are quantitatively measured with built-in evaluators or custom evaluators of your choice. To get started with the prompt flow sdk to evaluate your system, you can follow the [quickstart guide](https://learn.microsoft.com/azure/ai-studio/how-to/develop/flow-evaluate-sdk). Once you execute an evaluation run, you can [visualize the results in Azure AI Studio](https://learn.microsoft.com/azure/ai-studio/how-to/evaluate-flow-results).



  This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
  trademarks or logos is subject to and must follow
  [Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
  Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
  Any use of third-party trademarks or logos are subject to those third-party's policies.


pkgId: d8bd3bd83b681303b7bc4a9dfa76e1741d612bb267c387abd4a59d321fa5a8a2
name: python-co6co-help
arch: noarch
version: 0.0.17
epoch: 0
release: 1
summary: Development documents and examples for co6co
url: http://git.hub.com/co6co
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-co6co-0.0.17-1.src.rpm
location_href: Packages/python-co6co-help-0.0.17-1.noarch.rpm
checksum_type: sha256
description:
  ```
  0.0.1 初始版，测试发布功能
  0.0.2
  0.0.3.230817
  0.0.6
      增加两个方法 find_files getWorkDirectory
  0.0.7
      debug
  0.0.8
      新增 TaskManage,Executing
  0.0.9   正式 2024-09-10 降薪30%
      调整debug 输出格式
  0.0.10 发布
      增加  read_stream, write_stream
      增加  limitThreadPoolExecutor
  0.0.11
      新增 source.py 模块, Singleton
  0.0.12
      win 模块
      gps dsm
  0.0.13
      单例模式 装饰器
      增加  compile_source 方法
      增加类 EventLoop
  0.0.14
      log 增加方法 create_logger
  0.0.15
      util.__init__.py 优化
      安装时出现bug，使用下面版本
  0.0.16
      修复安装Bug
  0.0.17
      新增工具方法

  ```



  pip install co6co==0.0.2


pkgId: 3f45bc08489c049a6b7c542a2aeecf25b31e208672afe24616d39ddf68cd93d6
name: python-coSMicQC-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for coSMicQC
url: https://pypi.org/project/coSMicQC/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coSMicQC-0.1.2-1.src.rpm
location_href: Packages/python-coSMicQC-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  <img height="200" src="https://raw.githubusercontent.com/WayScience/coSMicQC/main/media/logo/with-text-for-light-bg.png?raw=true">



  ![PyPI - Version](https://img.shields.io/pypi/v/cosmicqc)
  [![Build Status](https://github.com/WayScience/coSMicQC/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/WayScience/coSMicQC/actions/workflows/run-tests.yml?query=branch%3Amain)
  ![Coverage Status](https://raw.githubusercontent.com/WayScience/coSMicQC/main/media/coverage-badge.svg)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)

  > 🌠 Navigate the cosmos of single-cell morphology with confidence — coSMicQC keeps your data on course!

  coSMicQC is a Python package to evaluate converted single-cell morphology outputs from CytoTable.

  It can be challenging to get "perfect" single-cell compartment segmentation across large high-throughput screens when performing object detection in CellProfiler (or similar software).
  Technical artifacts can arise during segmentation, leading to issues such as under-segmentation, over-segmentation, or the erroneous segmentation of background noise, smudges, or bright artifacts.

  In single-cell analysis, intriguing phenotypes often emerge by examining morphological differences.
  However, technical outliers in the data can obscure these biological insights, compromising the validity of the findings.

  By utilizing specific morphological features extracted with CellProfiler, particularly AreaShape features, you can identify technically incorrect segmentations.
  These can then be labeled or removed before further preprocessing steps, such as those performed with pycytominer.



  Install coSMicQC from [PyPI](https://pypi.org/project/coSMicQC/) or from source:

  ```shell

  pip install coSMicQC


  pip install git+https://github.com/WayScience/coSMicQC.git
  ```



  Please see our [contributing](https://WayScience.github.io/coSMicQC/main/contributing) documentation for more details on contributions, development, and testing.



  - [pycytominer](https://github.com/cytomining/pycytominer)
  - [CellProfiler](https://github.com/CellProfiler/CellProfiler)
  - [CytoTable](https://github.com/cytomining/CytoTable)


pkgId: bf03ac2d89bd6e0520145d788ffb6660c87c4ea3d7e38393280041b088f3e3b7
name: python-cobib-help
arch: noarch
version: 5.2.3
epoch: 0
release: 1
summary: Development documents and examples for cobib
url: https://gitlab.com/cobib/cobib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cobib-5.2.3-1.src.rpm
location_href: Packages/python-cobib-help-5.2.3-1.noarch.rpm
checksum_type: sha256
description:
  [![coBib](https://gitlab.com/cobib/cobib/-/raw/master/logo/cobib_logo.svg)](https://cobib.gitlab.io/cobib/cobib.html)



  [![pipeline](https://gitlab.com/cobib/cobib/badges/master/pipeline.svg)](https://gitlab.com/cobib/cobib/-/pipelines)
  [![coverage](https://gitlab.com/cobib/cobib/badges/master/coverage.svg)](https://gitlab.com/cobib/cobib/-/graphs/master/charts)
  [![PyPI](https://img.shields.io/pypi/v/cobib)](https://pypi.org/project/cobib/)

  coBib is a simple, command-line based bibliography management tool.
  It is the result of the need for an easy-to-use alternative to full-blown reference managers like Mendeley or Zotero.
  As such it follows some basic design goals:

  * **plain-text database**: which means you get full access and control over the database.
  * **git-integration**: as a benefit of the above, you can keep track of your database through version control.
  * **centralized database, location-independent library**: this means, that coBib *only* manages the
    database file in a centralized fashion but allows you to spread the actual contents of your
    library across the entire file system (this is the major different to
    [papis](https://papis.readthedocs.io/en/latest/library_structure.html)).
  * **command-line and TUI support**: all features are available through the command-line as well as a
    [textual](https://textual.textualize.io/)-based TUI




  For all common purposes you can install coBib via `pip`:

  ```
  pip install cobib
  ```

  Note: Use `pip3` if you still have Python 2 installed.

  If you would also like to install the man-page, you need to download the source
  code and do the following:

  ```
  git clone https://gitlab.com/cobib/cobib
  cd cobib
  make install_extras
  ```



  coBib is packaged in the AUR.
  * [cobib](https://aur.archlinux.org/packages/cobib/)
  * [cobib-git](https://aur.archlinux.org/packages/cobib-git/)



  coBib _might_ work on Windows as is, but it is not being tested so no guarantees are given.
  If you are using Windows 10 or later and are running into issues, you should be able to install and
  use coBib's full functionality within the Linux subsystem.




  To get started, you must initialize the database:

  ```
  cobib init
  ```

  If you would like to enable the git-integration, you should run:

  ```
  cobib init --git
  ```

  *and* enable `config.database.git` (see also [configuration](#configuration)).

  Be sure to check out my [Quickstart blog post](https://mrossinek.gitlab.io/programming/introducing-cobib/)
  for a more guided introduction compared to the following section!



  coBib provides an `import` command through which you can easily import your library
  from another bibliography manager. For more details check out:

  ```
  cobib import --help
  ```

  So far, coBib knows how to import your library from Zotero by simply running:

  ```
  cobib import --zotero
  ```

  Check out the following command, the man page or the online documentation for more details:

  ```
  cobib import --zotero -- --help
  ```





  You can now add new entries to your database (see also `cobib.commands.add`[^1]):

  ```
  cobib add --bibtex some_biblatex_file.bib
  cobib add --arxiv <some arXiv ID>
  cobib add --doi <some DOI>
  cobib add --isbn <some ISBN>
  ```

  **Note**: when adding data from a `.bib` file, make sure that it is in the Bib**La**Tex format!



  You can view the contents of your database with (see also `cobib.commands.list_`):

  ```
  cobib list
  ```

  You can show a specific entry with (see also `cobib.commands.show`):

  ```
  cobib show <some entry label>
  ```

  You can open an associated file of an entry with (see also `cobib.commands.open`):

  ```
  cobib open <some entry label>
  ```

  You can even search through your database with (see also `cobib.commands.search`):

  ```
  cobib search "some text"
  ```



  You can delete an entry with (see also `cobib.commands.delete`):

  ```
  cobib delete <some entry label>
  ```

  You can edit an entry manually with (see also `cobib.commands.edit`):

  ```
  cobib edit <some entry label>
  ```

  You can also apply simple modifications to multiple entries at once with (see also
  `cobib.commands.modify`):

  ```
  cobib modify tags:private -- <some entry label> <another entry label> ...
  ```



  You can export your database with (see also `cobib.commands.export`):

  ```
  cobib export --bibtex my_bibliography.bib
  cobib export --zip my_library.zip
  ```



  If you have enabled the git-integration, you can undo and re-apply changes to your database with
  (see also `cobib.commands.undo` and `cobib.commands.redo`):

  ```
  cobib undo
  cobib redo
  ```



  Each subcommand provides additional help via:

  ```
  cobib <subcommand> --help
  ```

  and you can find extensive information in the online documentation (linked above) and the man-page:

  ```
  man cobib
  ```



  Finally, you can also use coBib's TUI for a more interactive experience (see also `cobib.ui.tui`),
  by simply typing
  ```
  cobib
  ```

  Here is an example screenshot of the TUI when listing the entries in your database:

  ![coBib TUI List](https://gitlab.com/cobib/cobib/-/raw/master/html/cobib_tui_list.svg)

  And here is an example screenshot for listing search results:

  ![coBib TUI Search](https://gitlab.com/cobib/cobib/-/raw/master/html/cobib_tui_search.svg)




  You can overwrite the default configuration by placing a `config.py` file in `~/.config/cobib/`.
  The easiest way to get started with this file is by copying [`example.py`](https://gitlab.com/cobib/cobib/-/blob/master/src/cobib/config/example.py)
  or by using:

  ```
  cobib _example_config > ~/.config/cobib/config.py
  ```

  You can then modify it to your liking.

  You may also specify a different config file at runtime by using the `-c` or `--config` command line argument or by specifying a custom path in the `COBIB_CONFIG` environment variable.
  You can also disable loading of _any_ configuration file be setting this environment variable to one of the following values: `"", 0, "f", "false", "nil", "none"`.

  Finally, be sure to take a look at the man page (`man cobib`) and/or the online documentation for more information.




  coBib supports the implementation of plugins!
  You can find an example plugin in [this folder](./plugin) or read the docs of
  `cobib_dummy` (when viewing the hosted documentation online).




  coBib's documentation is hosted [here](https://cobib.gitlab.io/cobib/cobib.html).

  If you would like to generate a local version during development, you need to clone the source code, and install [`pdoc`](https://github.com/mitmproxy/pdoc) in order to generate it:

  ```
  git clone https://gitlab.com/cobib/cobib.git
  cd cobib
  pip install pdoc
  pdoc -d google -e cobib=https://gitlab.com/cobib/cobib/-/blob/master/src/cobib/ -t html -o docs src/cobib tests
  ```

  You can then browse the documentation from `docs/cobib.html`.




  I have started this project when I was looking into alternatives to popular reference managers such as Mendeley,
  which has more features than I use on a regular basis and does not allow me to work from the command line which is where I spent most of the time that I spent on the computer.

  Hence, I have decided to make it my own task of implementing a simple, yet fast, reference manager.
  coBib is written in Python and uses a YAML file to store its bibliography in a plain text format.



  You can find the detailed changes throughout coBib's history in [the Changelog](https://gitlab.com/cobib/cobib/-/blob/master/CHANGELOG.md).




  coBib is licensed under the [MIT License](https://gitlab.com/cobib/cobib/-/blob/master/LICENSE.txt).

  [^1]: References like this one get interpreted by the documentation generator. If you are reading this as the README page, you may find the [online documentation](https://cobib.gitlab.io/cobib/cobib.html) more enjoyable.

  [//]: # ( vim: set ft=markdown: )


  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).






  Pypi: https://pypi.org/project/cobib/5.2.3/



  - the interactive handling of notes inside the TUI (#148,!288)




  Pypi: https://pypi.org/project/cobib/5.2.2/



  - The `config.theme.dark` and `config.theme.design` settings have been replaced
    by the new `config.theme.theme` setting, which can be either the name of one
    of textual's builtin themes, or a custom `textual.theme.Theme` instance
    (#147,!279). Due to how recent these settings have been introduced (as part of
    5.2.0), I am opting for a quick removal in this bugfix release rather than a
    proper version bump (in the sense that they have likely not been adopted, yet)
    and the severness of the bug that this is causing outweighs the needs here.



  - compatibility with `textual>=0.86`




  Pypi: https://pypi.org/project/cobib/5.2.1/



  - compatibility with `textual>=0.80`




  Pypi: https://pypi.org/project/cobib/5.2.0/



  With the addition of the new `note` command, the database entry fields called
  `"note"` have obtained a special meaning. Use the `lint` command to check
  whether your database is affected by this. If it is, you should rename those
  fields.


  - new configuration settings to customize the appearance of coBib (!222):
    - `cobib.config.theme.dark`: to specify whether a dark or light theme is used
    - `cobib.config.theme.design`: to customize the colors themselves
    - the following settings to customize the appearance of `rich.Syntax` displays:
      - `cobib.config.theme.syntax.theme`
      - `cobib.config.theme.syntax.background_color`
      - `cobib.config.theme.syntax.line_numbers`
  - the `note` command (#139,!206).
    Please refer to its online documentation or the man-page for more details on
    how to use it.
    This new command comes with:
    - the `cobib.config.commands.note.default_filetype` setting
    - the `PreNoteCommand` and `PostNoteCommand` event hooks
  - (DEV) the `add_files` argument to the `BaseCommand.git` function
  - Python 3.13 is now officially tested and supported
  - new configuration settings for the search command (#146,!269)
    - For dealing with skipping/including associated files during searches:
      - `cobib.config.commands.search.skip_files` sets the default
      - `--skip-files` overwrites this at runtime (this is not actually new)
      - `--include-files` overwrites this at runtime (the opposite)
    - For dealing with skipping/including associated notes during searches:
      - `cobib.config.commands.search.skip_notes` sets the default
      - `--skip-notes` overwrites this at runtime (this is not actually new)
      - `--include-notes` overwrites this at runtime (the opposite)


  - the keybinding to recursively toggle all folds in the TUI's search result view
    was changed from `ENTER` to `BACKSPACE` (!218)
  - (DEV) `cobib.ui.components.entry_points` was moved to `cobib.utils.entry_points`
  - replaced the custom help screen with textual's new builtin help panel (!240)


  - the behavior of the `Home` and `End` keybindings in the TUI's list view (!217)
  - gracefully handles Zotero imported entries without a `journal` field (#145)




  Pypi: https://pypi.org/project/cobib/5.1.3/


  - the behavior of the `Home` and `End` keybindings in the TUI's list view (!217)




  Pypi: https://pypi.org/project/cobib/5.1.2/


  - support database locations in nested folders of a git repository (!204)




  Pypi: https://pypi.org/project/cobib/5.1.1/



  - when printing the changelog, do not remove list indents




  Pypi: https://pypi.org/project/cobib/5.1.0/



  Check out my blog post to learn more about the features of this new release:
  https://mrossinek.gitlab.io/programming/cobib-becomes-fuzzy/


  - approximate (or fuzzy) filter matching and search functionality (#107,#130,!177)
    - the `list` and `search` commands now support the following features to
      perform approximate filter matching and searching, respectively:
      - LaTeX sequences can be decoded to Unicode characters:
        - using `--decode-latex` from the command-line
        - setting `config.commands.list_.decode_latex = True`
        - setting `config.commands.search.decode_latex = True`
      - Unicode characters can be converted to a close ASCII equivalent:
        - using `--decode-unicode` from the command-line
        - setting `config.commands.list_.decode_unicode = True`
        - setting `config.commands.search.decode_unicode = True`
      - a number of fuzzy errors can be set (this requires the optional dependency
        [`regex`](https://pypi.org/project/regex/) to be installed):
        - using `--fuzziness <int>` from the command-line
        - setting `config.commands.list_.fuzzines` to some integer
        - setting `config.commands.search.fuzzines` to some integer
  - (DEV) the following method arguments have been converted to be accepted only
    as keyword arguments:
    - in `cobib.database.Entry.matches`: `ignore_case`
    - in `cobib.database.Entry.search`: `context`, `ignore_case`, and `skip_files`
  - (DEV) the return-type of `cobib.database.Entry.search` has been changed




  Pypi: https://pypi.org/project/cobib/5.0.1/


  - the ability to use an empty string as the separator in `config.database.format.label_suffix` (#138)




  Pypi: https://pypi.org/project/cobib/5.0.0/



  - the ability to add custom `commands`, `importers`, and `parsers` through entry points (#135, !139)
    - (DEV) a dummy plugin show-casing these extensions


  - the entire `shell_helper` module has been replaced as follows (!139):
    - the following deprecated helper methods were removed without replacement:
      - `_list_commands`
      - `_list_filters`
      - `_list_labels`
    - the following secondary commands have been refactored:
      - `_lint_database` is now `cobib.commands.lint.LintCommand`
      - `_unify_labels` is now `cobib.commands.unify_labels.UnifyLabelsCommand`
      - `_example_config` is now `cobib.config.command.ExampleConfigCommand`
  - the interactive disambiguation mechanism during the `add` command now handles
    multiple matching related entries (#121,!168)
    - this includes the ability to `cancel` the disambiguation and entry addition



  - the previously deprecated `console` attribute of all commands has been removed (!139)
  - the previously deprecated `prompt` attribute of all commands has been removed (!139)
  - the `cobib.ui.shell_helper` and `cobib.utils.shell_helper` modules have been removed (!139)
  - the previously deprecated `--update` argument of the `add` command (!168)
  - the previously deprecated `--skip-existing` argument of the `add` command (!168)
  - the previously deprecated `LabelSuffix.CAPTIAL` attribute (!168)
  - Python 3.8 is no longer supported (!173)




  Pypi: https://pypi.org/project/cobib/4.5.0/


  - the new `cobib.utils.context.get_active_app` method which returns any running
    textual App and replaces the need for the `cobib.utils.prompt.Prompt.console`
    and `cobib.utils.progress.Progress.console` (which have been removed) (!137)
  - `cobib.parsers.YAMLParser.parse` can now also parse strings directly (rather
    than always interpreting the argument as the path to a file) (!137)
  - the `review` command (#131,!137).
    Please refer to its online documentation or the man-page for more details on
    how to use it.
  - the `cobib.database.Entry.merge` method (!137)


  - log messages will now be displayed in the `LogPanel` of the TUI (which can be
    toggled with the `z` keybinding) (#132,!133)
  - the `cobib.ui.components.prompt` module has been refactored into `cobib.utils.prompt` (!133)


  - the `console` argument to all commands has been deprecated since it no longer
    has any effect (!133)
  - the `prompt` argument to all commands has been deprecated since it no longer
    has any effect (!133)
  - access to the following `shell_helper` commands will change in the next release:
    - `cobib _lint_database` will become `cobib lint`
    - `cobib _unify_labels` will become `cobib unify_labels`
    - `cobib _example_config` will become `cobib example_config`


  - loading a cached database will be bypassed during `_lint_database` (#133)
    - to support this the `bypass_cache` keyword-argument was added to the
      `Database.read` method


  - official Windows support label. It _might_ work but no guarantees are made (#136)




  Pypi: https://pypi.org/project/cobib/4.4.0/


  - a primitive caching mechanism to speed up the database loading. This feature
    is enabled by default and will store its cache at `~/.cache/cobib/databases/`.
    You can configure the location via `config.database.cache` or even disable
    caching entirely by changing this setting to `None`. (see also #129 and !108)
  - added the `-r/--remove` option to the `modify` command (#128)
    - this can achieve the opposite of `-a/--add` in the sense that it will try to
      remove the specified modification from a list or subtract a number from
      numeric values
    - other field types than lists or numbers are not supported by this option
  - added the `-l/--limit` option to the `list` command (#127)
    - exposed the `ListCommand.sort_entries` method in the public API
    - added the `ListCommand.execute_dull` method in the public API
  - the `search`, `export`, and `modify` commands now also support sorting and limiting options to be
    passed onto the `list` command (along with the already existing filtering options)
  - the `config.tui.tree_folding` setting which allows you to configure the
    default folding state of the tree nodes in the TUI's search result view
  - the `ENTER` binding in the TUI's search result view to recursively toggle all
    folds of the current node


  - when using the TUI you may now use the `:show <label>` command to jump to the
    specified label (#126,!116)
  - the `search` command now reports its progress live (!117)


  - unblocked the vertical scrollbar of the TUI's list view from the scroll offset




  Pypi: https://pypi.org/project/cobib/4.3.1/


  Note, that the introduction of the detailed author information parsing in v4.3.0
  resulted in possible breaking of a custom `config.database.format.label_default`
  setup. This bugfix release is meant to emphasize this breaking change and
  updates the documented example in the example configuration file. For the sake
  of verbosity, here is the change applied to the example:

  - old: `"{unidecode(author.split(' and ')[0].split()[-1])}{year}"`
  - new: `"{unidecode(author[0].last)}{year}"`




  Pypi: https://pypi.org/project/cobib/4.3.0/




  coBib now has the ability to store more detailed author information (see #92 and
  !88). This means, that the `author` field of an entry is analyzed in more detail
  and coBib will separate out the first and last names as well as name pre- and
  suffixes. The new setting `config.database.format.author_format` determines,
  whether this detailed information is kept directly in the database (the
  `AuthorFormat.YAML` setting; the **new default**) or is only constructed at
  runtime and the author field is still simply saved in BibLaTeX form
  (`AuthorFormat.BIBLATEX`).

  Note, that the `YAML` format also implies, that Unicode characters are allowed
  and will *not* be encoded in LaTeX form. This has an effect on how you may need
  to format your searches. See also #130 for some more insights on this.

  If you have company names or any author name which you want to have treated
  verbatim, you can simply wrap it in curly braces (e.g. `{My Company}`).
  Refer to the online documentation of `cobib.database.Author` and the above
  setting for more details.


  coBib now has a [Wiki](https://gitlab.com/cobib/cobib/-/wikis/home) where we can
  gather useful configuration resources and other details which may not make it
  into the full documentation.

  For example, if you are interested in the tracking more metadata of your
  database (as suggested in #123), be sure to check out
  [this wiki page](https://gitlab.com/cobib/cobib/-/wikis/Useful-Event-Hooks)!


  - the `-f` short-hand alias for the `--field` argument of the `open` command
  - the `opened_entries` attribute of the `OpenCommand` (which is accessible during the `PostOpenCommand` hook)
  - the new `git` command to simplify running git operations on the database (#124)
  - new bindings for `Home`, `End`, `PageUp`, and `PageDown` in the TUI
  - (DEV) added a new `DEPRECATED` logging level which has value 45
  - Python 3.12 is now officially tested and supported
  - the `config.commands.show.encode_latex` setting
  - the `encode_latex` attribute to the `BibtexParser`
  - the `config.database.format.verbatim_fields` setting
  - the `config.database.format.author_format` setting. The new default behavior
    is to store detailed author information in YAML form.
  - the `encode_latex` keyword-argument to the `Entry.stringify` method
  - the `Entry.formatted` method. This replaces the `Entry.escape_special_chars` method.


  - an error will be logged when a file is not found during the `open` command
  - the following commands are now treated specially when run via the `:` prompt of the TUI:
    - `init`: will log an error
    - `git`: will log an error
    - `show`: will log a warning


  - The `LabelSuffix.CAPTIAL` value because it was misspelled. Please use `LabelSuffix.CAPITAL` instead.


  - non-asynchronous commands triggered via the `:` prompt of the TUI will no longer break it (#125)
  - ensure UTF-8 encoding is used for downloaded data (this fixes many odd encounters w.r.t. special characters)
  - the spelling of the `LabelSuffix.CAPITAL` value (it used to be spelled `LabelSuffix.CAPTIAL`)


  - the `Entry.escape_special_chars` method. Use `Entry.formatted` instead.




  Pypi: https://pypi.org/project/cobib/4.2.0/


  - added the `config.tui.scroll_offset` setting
  - added the `--field` command line option to the `open` command
  - (DEV) added a new `HINT` logging level which has value 35 and thus allows to
    provide information to the user with a higher priority than `WARNING`
  - added the new `config.tui.preset_filters` (#114)
    - preset filters can be selected from the TUI via the `p` key binding
    - the first 9 filters can be selected directly by pressing the respective number
    - pressing `0` resets any applied filter
  - implemented special tags (#63,!83)
    - adds new builtin tags which will trigger special highlights of entries: `new`, `high`, `medium`, `low`
    - adds the new `config.theme` settings section for configuring these settings
    - you can also add more special tags via `config.theme.tags.user_tags`
  - added the `--skip-files` command line option to the `search` command


  - unicode symbols in entry labels will now be replaced with ascii ones (#119,#120)
    - this is configured via the `config.database.format.default_label` setting, so if you are using a
      custom value for this, be sure to update your config to make use of this feature
  - some user-visible logging messages around label disambiguation have been added (see also #121)
  - a warning has been added when the YAML parser encounters identical labels (which normally should
    not occur in the database but if it does, coBib does not really know how to resolve this)
  - DOI redirect links are now followed recursively (up to 3 times), improving PDF
    download link detection in the process (#97)


  - the `config.commands.search.highlights` section is deprecated in favor of `config.theme.search`


  - retain scroll position in the TUI's list view




  Pypi: https://pypi.org/project/cobib/4.1.0/


  - added the following settings which specify whether or not to preserve
    associated files during the respective commands being run:
    - `config.commands.delete.preserve_files`
    - `config.commands.edit.preserve_files`
    - `config.commands.modify.preserve_files`
  - added a confirmation prompt before deleting an entry (#110)
    - this prompt can be disabled by setting `config.commands.delete.confirm` to `False`
  - added the `--no-ignore-case` (`-I` for short) command line options to the
    `list` and `search` command (#116)
  - added the `--no-preserve-files` command line options to the `delete`, `edit`
    and `modify` command (#116)
  - added the `config.commands.search.context` setting which configures the
    default number of context lines to be provided for search query matches
  - added more options to configure the automatic download behavior:
    - the new `config.commands.add.skip_download` setting
    - the new `--force-download` option of the `add` command
    - the new `config.commands.import_.skip_download` setting
    - the new `--force-download` option of the `import` command
  - the user is asked for confirmation when quitting the TUI (!71)


  - refactored the TUI by leveraging textual's `Screen` concept (#111,!71)
    - this means the TUI will look slightly different but no real functional change has occurred
    - the view of an `Entry` can now be scrolled when the output exceeds the available space
  - switched from the `BeautifulSoup` HTML parser to `lxml`
    - this is supposed to give more accurate results but adds an extra dependency


  - The following shell helpers are no longer used with the zsh completion being
    removed. Thus, these methods will be removed in the future:
    - `cobib _list_commands`
    - `cobib _list_filters`
    - `cobib _list_labels`
    - If you see warnings because of this while you are using the CLI, you
      probably still have the (now removed) zsh completion script installed. You
      should remove the `_cobib` file which will be located in one of the
      directories listed in your `$FPATH` environment variable.


  - the proper pre-population of the TUI prompt during the sorting action (#117)
  - preserves the value of `config.commands.list_.default_columns` and
    properly removes a field if it is no longer sorted by in the TUI (#117)
  - properly updates the list of entries in the TUI after changing the database contents;
    for example via `add` (#113) or `delete` (#113) or `edit` (#118)
  - an issue where file-accessing operations performed on a newly added entry within
    the same TUI session would fail because the path would not be iterated correctly
  - the live updating of the download progress bar inside the TUI (#112)


  - the crude and very slow zsh completion script




  Pypi: https://pypi.org/project/cobib/4.0.0/


  - Configuration settings can no longer be set by item access and instead must
    use attribute syntax. For example you need to change:
    ```python
    config["database"]["git"] = True
    ```
    to
    ```python
    config.database.git = True
    ```
    - the `config.commands.list` section had to be renamed to `config.commands.list_`
    - the `config.tui` section has been entirely removed
  - The `cobib.commands.list` module was moved to `cobib.commands.list_`.
  - The function signature of all command- and importer-related events has changed!
    For more details please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html).


  - Python 3.11 is now officially tested and supported
  - Full rewrite of all commands to use `rich` for a nicer CLI (#78,!51)
  - Full rewrite of the TUI based on `textual` (#78,!51)
  - the `--disambiguation` argument of the `add` command (#99,!58)
  - the `--ignore-case` argument of the `list` command (#105)
    - this also comes with the new `config.commands.list_.ignore_case` setting
  - the `search` command now accepts multiple query strings at once which will be
    searched over independently (#106)


  - the new default value of `config.parsers.yaml.use_c_lib_yaml` is now `True` as announced in version [3.4.0]
  - refactored the entire config as a dataclass (!63)
    - this implies that settings can only be set via attributes
    - but as a benefit the maintainability and documentation have improved significantly
  - The function signature of all command-related events has changed! Please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)
    for more details. (!63)
  - The function signature of all importer-related events has changed! Please refer to the
    [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)
    for more details. (!66)
  - the API of the `cobib.commands` and `cobib.importers` module has been improved (!64)
    - this should not have any end-user facing effects
  - the `cobib.commands.list` module was moved to `cobib.commands.list_`


  - the `--update` argument of the `add` command is deprecated in favor of `--disambiguation update`
  - the `--skip-existing` argument of the `add` command is deprecated in favor of `--disambiguation keep`


  - the detection whether an entry already exists broke when label disambiguation was added in [3.3.0]
    and is now fixed by means of an interactive prompt during the `add` command


  - the warning triggered upon setting `config.database.format.month` which got removed in [3.1.0]
  - Python 3.7 is no longer supported




  Pypi: https://pypi.org/project/cobib/3.5.5/


  - opening of non-list type fields (#100)




  Pypi: https://pypi.org/project/cobib/3.5.4/


  - missing files encountered during searching will log warnings gracefully instead of harshly
  - handle newline characters in the TUI (#98)




  Pypi: https://pypi.org/project/cobib/3.5.3/


  - incorrect author concatenation in ISBN Parser
  - using the disambiguated label for the names of downloaded files (#96)




  Pypi: https://pypi.org/project/cobib/3.5.2/


  - run TUI on BSD platforms (!52)




  Pypi: https://pypi.org/project/cobib/3.5.1/


  - safely check cache existence before attempting to write (#94)




  Pypi: https://pypi.org/project/cobib/3.5.0/


  The plan is to switch to [rich][rich] and [textual][textual] instead of the current curses TUI.
  This will open up some great possibilities for a much more modern UI.

  However, this change will require some *major* refactoring including breaking changes of the API
  and some of the user configuration options. It will also be a rather drastic change in style.
  Thus, I will attempt to support v3.5 with bugfix releases until 1.1.2023

  It will likely take a few months until v4.0 gets released but I am starting development on it now.
  You can follow the progress here: <https://gitlab.com/cobib/cobib/-/issues/78>

  [rich]: https://github.com/Textualize/rich
  [textual]: https://github.com/Textualize/textual


  - the configuration loading can be disabled via the environment variable `COBIB_CONFIG`
      - values which disable the loading entirely are: `"", 0, f, false, nil, none`
      - you can also specify a custom path to a configuration file in this variable


  - the `INI`-style configuration got fully removed (as deprecated in [3.0.0] - 2021-04-10)




  Pypi: https://pypi.org/project/cobib/3.4.0/

  - coBib now requires the `requests-oauthlib` package
      - technically this is an optional dependency for now, but it will likely become a requirement soon


  - the new `config.parsers.yaml.use_c_lib_yaml` setting which significantly improves loading performance
      - this setting will change its default value to `True` in version 4.0.0
  * the `Import` command (#86,!49):
      - can be used to import libraries from other bibliography managers (see next bullet)
      - see `cobib import --help` for more information
  - the `cobib.importers` module:
      - provides importer classes for various other bibliography managers
      - these get registered at runtime under the `cobib import` command
      - this release provides the `--zotero` importer
      - see `cobib import --zotero -- --help` for more information
  - the `config.logging.cache` option, specifying the location of a simple json cache
  - the `config.commands.open.fields` option, specifying the names of the data fields which are checked for openable URLs (#89)


  - the `PreFileDownload` event now takes an additional argument: `headers: Optional[Dict[str, str]]`


  - downloaded file names will not duplicate the `.pdf` suffix




  Pypi: https://pypi.org/project/cobib/3.3.2/


  - re-enable the terminal keypad during resize event
      - this ensures proper arrow-key behavior after returning from an external editor
  - clear screen after closing TUI to remove all screen artifacts


  - remove warning when using the DOI parser because the upstream issue related to #91 got fixed




  Pypi: https://pypi.org/project/cobib/3.3.1/


  - erroneous label disambiguation of Entry labels which already conform with `config.database.format.default_label_format` (#87,!47)
  - do not add empty file list when unifying database


  - log warning when using the DOI parser because of (#91)




  Pypi: https://pypi.org/project/cobib/3.3.0/


  - print Changelog since the last run version (cached in `config.logging.version`) (#82)
  - the `AddCommand` now has a new `--update` option (#79,!41)
  - the `_lint_database` utility now takes the `--format` argument, which automatically resolves all lint messages (#81,!42)
  - the new `URLParser` (available via `cobib add --url <URL>` (#84,!44)
      - it attempts importing from a plain URL
      - simultaneously the arXiv, DOI, and ISBN parsers now also support URL containing a matching identifier directly
  - the `--dry` argument of the `ModifyCommand` to prevent errors during large bulk modifications
  * the `config.database.format.label_default` and `config.database.format.label_suffix` options (#85,!45)
      - labels will automatically be formatted according to the default option
      - if labels conflict with existing ones, the suffix option will be used for disambiguation
      - the `AddCommand` has a new `--skip-existing` option which disables automatic label disambiguation
      - use `cobib _unify_labels --apply` to unify all labels in your database
  - subscribable events (#71,!46)
      - allows registering of hooks to be executed in certain situation
      - more information is provided at the [online documentation](https://cobib.gitlab.io/cobib/cobib/config/event.html)


  - when an unknown variable is encountered in the modification of the `modify` command it falls back to an empty string rather than the name of the attempted variable


  - the `-s` option of the `AddCommand` is no longer available. You need to write out `--skip-download`
  - the `ID` filter argument on the `list` command (deprecated in v3.2.0 in favor of the `label` filter)




  Pypi: https://pypi.org/project/cobib/3.2.1/


  - when adding multiple entries at once, continue adding after encountering a single duplicate (#83)




  Pypi: https://pypi.org/project/cobib/3.2.0/


  - basic auto-downloading of PDF files for arXiv IDs and configured DOIs (#25,!35,!39):
      - the default download location can be configured via `config.utils.file_downloader.default_location`
      - on a per addition basis, this default can be overwritten via the `--path` keyword option of the `AddCommand`
      - if a file already exists in this location of the file system, the download will be skipped
      - download for DOI entries must configure URL patterns in `config.utils.file_downloader.url_map`
      - on a per addition basis, the entire automatic download can be skipped with `--skip-download`
  - automatic journal abbreviations (#62,!36):
      - users can configure a list of journal abbreviations via `config.utils.journal_abbreviations`
      - if present, coBib will store the journal in its elongated form
      - a user can then automatically convert to abbreviated forms during exporting (see the new `--abbreviate` and `--dotless` arguments)
  - Tentative Windows support by disabling the TUI
  - a `--preserve-files` argument was added to the following commands. Unless it is given, these will delete/rename associated files of affected entries:
      - `DeleteCommand`
      - `EditCommand`
      - `ModifyCommand`


  - the `modifications` of a `ModifyCommand` get interpreted as f-strings (#77,!37):
      - available variables are the entry's label and data fields
  - any `ListCommand` filter gets interpreted as a regex pattern (#76)


  - the `ID` filter argument was fully replaced by `label`, unifying the CLI API. Support will be dropped in v3.3.0


  - Removed (most) duplication of log messages




  Pypi: https://pypi.org/project/cobib/3.1.1/


  - Pypi package metadata




  Pypi: https://pypi.org/project/cobib/3.1.0/


  - the YAML format of the database has been extended to support the following: (#55)
      - numbers can be stored as integers
      - the `ID` field is no longer required and will be properly inferred from the label
      - the following fields can be stored as lists: `file`, `tags`, `url`
  - three new configuration options were added to complement the above list format options:
      - `config.database.stringify.list_separator.file`
      - `config.database.stringify.list_separator.tags`
      - `config.database.stringify.list_separator.url`
  - the `_lint_database` shell utility has been added which can be used to detect possible improvements for the database
  - the append-mode of the `ModifyCommand` was implemented (#60):
      - specifying `-a`/`--add` will add the modification value to the field of the entries rather than overwrite it
      - this can be used for string or list concatenation and even number addition on numeric fields


  - use file paths relative to user-home (achieved by replacing `os.path` with `pathlib`) (#69)
  - the shell helper `_list_tags` has been renamed to `_list_labels`
  - (DEV): the `logging` and `zsh_helper` modules have been relocated to the `cobib.utils` package
  - `+` symbols will no longer be stripped from tags (this was a left-over artifact from pre-v1.0.0)


  - the `config.database.format.month` setting is deprecated in favor of proper three-letter code encoding to support common citation style macros (!34)


  - renaming the label during the `edit` command does not leave the previous label entry behind:
      - a followup also ensured that renaming entries happens in-place (#75)
  - the sorting of the `list` command




  Pypi: https://pypi.org/project/cobib/3.0.0/

  - From now on, `coBib` is the official way of spelling!


  - coBib's documentation is now generated by [`pdoc`](https://pdoc.dev/) and hosted at https://cobib.gitlab.io/cobib/cobib.html
  - (DEV): the `cobib.database.Database`-Singleton has been added to centrally manage the bibliographic runtime data (!28)
  - the new option `config.database.format.suppress_latex_warnings`
  - the new option `config.commands.edit.editor` which takes precedence over the `$EDITOR` variable


  - the `INI`-style configuration is replaced with a `Python`-based configuration (#54,!25)
      - for guidance on how to migrate an existing configuration please read https://mrossinek.gitlab.io/programming/cobibs-new-configuration/
  - (DEV): `cobib.parser.Entry` has been moved to `cobib.database.Entry`
  - the `cobib.parsers` module has been extracted (prep for #49, !28)
  - the filenames of the associated files are preserved when exporting to a Zip file
  - when trying to add an entry with an existing label, the database is not written to and a warning is raised early
  - month conversion and special character escaping are only done upon saving entries to the database
  - the path to the default logfile can now be configured via `config.logging.logfile` and defaults to `~/.cache/cobib/cobib.log`


  - the `INI`-style configuration is deprecated
      - new configuration options will not be added to this style
      - only bugs which fully break usability will be fixed with regards to this configuration style
      - legacy-support will be fully removed on 1.1.2022


  - the ZSH helper utilities now respect the `-c`, `-l`, and `-v` command line options
  - the `RedoCommand` should only revert a previously `UndoCommand` operation (#65)
  - the `SearchCommand` got some contexts improvements and correctly splits grep results
  - unwrapping does not crash the TUI if the cursor was multiple lines below the new buffer height
  - line continuation guides are not swallowed by current line highlighting
  - ensure the TUI's top line does not become negative
  - the TUI's handler for resizing events
  - `JSONDecodeError`s thrown by the `ISBNParser` are caught and handled gracefully


  - the functions `read_database()` and `write_database()` are no longer available (!28)




  Pypi: https://pypi.org/project/cobib/2.6.1/

  Note: [2.6.1] was not released from the `master`-branch, which resulted in a non-linear development.


  - `init --git` will not initialize a repository unless git has configured both, `name` and `email`


  - TUI no longer crashes when aborting to quit (#64)




  Pypi: https://pypi.org/project/cobib/2.6.0/


  - Git integration (#44, !20):
      - will automatically track any changes done to the database file with git
      - must be enabled by setting the `DATABASE/git` option to `True` **and** running `cobib init --git`
      - Note, that you must have at least set a `name` and `email` in the git config!
  - Undo/Redo commands to operate on git history of the database (#59,!23)
      - for obvious reasons these commands require the Git integration (see above) to be enabled
  - the `Prompt` command inside of the TUI:
      - allows executing arbitrary CoBib CLI commands
      - the default key binding is `:`
  - the `Modify` command: (#60,!24)
      - allows bulk modification of multiple entries in a `<field>:<value>` format
      - for now, this will **always** overwrite the field with the new value!
      - an extension to appending values is planned for a later release
      - the set of entries to be modified can be specified just like with the `export` command through `list`-command filters or manual selection (by setting the `--selection` flag)


  - the viewport history is preserved correctly (#21,!22)
      - this allows performing a search while showing an entry and reverts back to the correct view after quitting the search
      - the changes mainly involved refactoring of the `cobib/tui` module
  - the **positional** argument of the `modify` and `search` has been renamed internally from `list_arg` to `filter`
      - this should not have any visible effect to an end-user but may be relevant to developers


  - gracefully handle multiple terminal sizing issues with regards to popups (#58)
  - catch messages on `stdout` during deletion from TUI
  - added missing help strings to the TUI help menu


  - The `--force` argument to the `init` command has now been removed (after being deprecated in v2.5.0).




  Pypi: https://pypi.org/project/cobib/2.5.0/


  - support for multiple associated files (#42,!19)
  - interactive menu when opening an entry with multiple associated files (!19)


  - The `--force` argument to the `init` command has been deprecated. I don't think there is any
    benefit to providing the user the option to nuke their database file from the CLI. Instead,
    they can simply edit the file manually.


  - always store years as strings to be compatible with bibtexparser
  - handle invalid arXiv or DOI IDs gracefully (#57)




  Pypi: https://pypi.org/project/cobib/2.4.1/


  - ISBN parser was missing the ENTRYTYPE and did not use strings for number fields
  - the ISBN parser can now handle empty entries (#53)
  - the TUI will not crash on stdout/stderr messages exceeding the window width
  - the TUI respects quoted strings in the prompt handler (#52)




  Pypi: https://pypi.org/project/cobib/2.4.0/


  - the `FORMAT/default_entry_type` option used for manual entry addition
  - a **manual** insertion mode available through `edit -a new_label` and `add -l new_label`
  - a ISBN-based parser for adding new entries (#45)
  - the TUI-based `select` command (and corresponding settings) (#8,!18)
  - the `--selection` argument for the `export` command (!18)


  - TUI color highlighting is now prioritized (!17)


  - support URLs in file field during `open` command (#47)
  - the TUI no longer crashes when encountering long prompt inputs (#48)
  - the `edit` command can handle labels which start with common substrings (#46)
  - support multiple ANSI colors on a single line (#50)




  Pypi: https://pypi.org/project/cobib/2.3.4/


  - another AUR package installation error




  Pypi: https://pypi.org/project/cobib/2.3.3/


  - AUR package installation error



  Pypi: https://pypi.org/project/cobib/2.3.2/


  - option to default to case-insensitive searching (`DATABASE/search_ignore_case`)


  - clearing the prompt, aborts the command execution


  - search command correctly handles missing arguments in TUI (#43)



  Pypi: https://pypi.org/project/cobib/2.3.1/


  - faulty Pypi package



  Pypi: https://pypi.org/project/cobib/2.3.0/


  - Logging functionality has been added. The verbosity level can be controlled via `-v` (INFO) and `-vv` (DEBUG).
    As soon as the TUI starts, all logging output is redirected to `/tmp/cobib.log`.
  - Command line argument `-l` or `--logfile` can be used to specify the output path of the log. This will overwrite the `/tmp/cobib.log` location.
  - the `TUI/scroll_offset` setting was added. It defaults to `3` and behaves similar to Vim's `scrolloff` setting.
  - Configuration validation has been added. This extends the logging functionality to support more runtime debug information.
  - popup window support: stdout and stderr messages are presented in a popup similarly to the help window


  - `-v` command line argument now refers to `--verbose` rather than `--version`
  - Performance of the `add` command has been improved by not refreshing the database when outside of the TUI.


  - bug when resizing causes the window width to become greater than the buffer width (#39)
  - do not escape special characters in labels (#40)
  - avoid special character encoding in file paths



  Pypi: https://pypi.org/project/cobib/2.2.2/


  - current line highlight if viewport is wider than buffer was not correctly reset
  - the `ignore_non_standard_types` setting had no effect



  Pypi: https://pypi.org/project/cobib/2.2.1/


  - when wrapping the TUI lines, indent until after the label column (#26)
  - renamed `default.ini` to `example.ini` in the documentation folder


  - current line highlight after viewport width was not correctly reset
  - correctly convert boolean configuration options (#34)
  - fix crash of TUI in wrap command when viewport is empty (#37)
  - default configuration settings are managed centrally and consistently (#35)




  Pypi: https://pypi.org/project/cobib/2.2.0/


  - allow configuring the program used to `open` associated files
  - prompt user before actually quitting CoBib (#33)
  - implements the Search command (#7, !12)


  - the default value of the `open` command was not set correctly




  Pypi: https://pypi.org/project/cobib/2.1.0/


  - added half- and full-page scrolling (#22)


  - importing from `bibtex` data defaults to **not** ignored non-standard entry types (#28)
  - suppress LaTex encoding warnings except when adding entries (#29)
  - `Search` and `Select` print warnings to the prompt while not implemented


  - `init` command ensures directory of database file exists
  - remove window artifacts after `help` menu is closed (#20)
  - configuration file detection was missing a user home expansion (#31)



  Pypi: https://pypi.org/project/cobib/2.0.0/


  - respect sort order reversing and filter `XOR`ing from the TUI (#18)
  - `edit` command on Mac OS (#19)


  - made `init` command safe against database overwriting
  - TUI: list entries in reverse order by default (config: TUI/reverse_order)




  Pypi: https://pypi.org/project/cobib/2.0.0b4/


  - reset viewport position when updating buffer




  Pypi: https://pypi.org/project/cobib/2.0.0b3/


  - properly assert valid current line number




  Pypi: https://pypi.org/project/cobib/2.0.0b2/


  - fixed TUI startup




  **Warning**: do NOT use! The TUI is broken in this release!

  Pypi: https://pypi.org/project/cobib/2.0.0b1/


  - TUI does not crash when opening an entry with no associated file
  - correctly reset current line positions after filtering and editing




  Pypi: https://pypi.org/project/cobib/2.0.0b0/


  - _internal_: refactored the config into a class
  - centralized the database handling to improve performance (#12,!9)


  - the `Show` command does not break after scrolling the viewport (#13)




  Pypi: https://pypi.org/project/cobib/2.0.0a2/


  - user configuration options for:
      - TUI colors
      - TUI key bindings
      - TUI default list arguments
  - help window highlighting


  - sorting and filtering commands remain persistent when updating the list view




  Pypi: https://pypi.org/project/cobib/2.0.0a1/


  - Added a basic curses-based TUI (#5,!7)


  - _internal_: refactored commands into separate module




  Pypi: https://pypi.org/project/cobib/1.1.0/


  - add `FORMAT.month` configuration option to configure the default type for
      month fields (defaults to `int`) (#3,!4)
  - escape special LaTeX characters (#2,!5)


  - `list` no longer breaks with a `KeyError` when a queried field does not exist
      in any bibliography entry (!2)
  - `--label` can now correctly overwrite the ID (#4,!3)


  - `set_config()` and global `CONFIG` exported to separate module




  Pypi: https://pypi.org/project/cobib/1.0.2/

  Note: this removal is not seen as a MINOR version bump because this is
        essentially a long out-standing bug fix


  - doi extraction from pdf files (476efc4f)
    - also removes the ability to add entries directly via pdf files




  Pypi: https://pypi.org/project/cobib/1.0.1/


  - metadata for pypi




  First MAJOR release. Also available via Pypi: https://pypi.org/project/cobib/1.0.0/
  The project was renamed from `CReMa` to `CoBib`


  - allow sorting the list output (2a5a94f1)
  - crude and slow (!!!) zsh completion (9f28f441)
  - support Darwin's `open` command


  - suppress list output when exporting
  - add used tags to columns when listing
  - sort YAML database entries by keys (d2af42d2)


  - fixed arxiv parser (7ce3726f)




  Note: this release was not marked MAJOR because this is still a WIP and early
        alpha release.


  - complete rewrite to use a plain-text `yaml` database instead of `sqlite3` !1


  - `sqlite3` database





  - initial version with a basic `sqlite3`-based database


  [Unreleased]: https://gitlab.com/cobib/cobib/-/compare/v5.2.3...master
  [5.2.3]: https://gitlab.com/cobib/cobib/-/tags/v5.2.3
  [5.2.2]: https://gitlab.com/cobib/cobib/-/tags/v5.2.2
  [5.2.1]: https://gitlab.com/cobib/cobib/-/tags/v5.2.1
  [5.2.0]: https://gitlab.com/cobib/cobib/-/tags/v5.2.0
  [5.1.3]: https://gitlab.com/cobib/cobib/-/tags/v5.1.3
  [5.1.2]: https://gitlab.com/cobib/cobib/-/tags/v5.1.2
  [5.1.1]: https://gitlab.com/cobib/cobib/-/tags/v5.1.1
  [5.1.0]: https://gitlab.com/cobib/cobib/-/tags/v5.1.0
  [5.0.1]: https://gitlab.com/cobib/cobib/-/tags/v5.0.1
  [5.0.0]: https://gitlab.com/cobib/cobib/-/tags/v5.0.0
  [4.5.0]: https://gitlab.com/cobib/cobib/-/tags/v4.5.0
  [4.4.0]: https://gitlab.com/cobib/cobib/-/tags/v4.4.0
  [4.3.1]: https://gitlab.com/cobib/cobib/-/tags/v4.3.1
  [4.3.0]: https://gitlab.com/cobib/cobib/-/tags/v4.3.0
  [4.2.0]: https://gitlab.com/cobib/cobib/-/tags/v4.2.0
  [4.1.0]: https://gitlab.com/cobib/cobib/-/tags/v4.1.0
  [4.0.0]: https://gitlab.com/cobib/cobib/-/tags/v4.0.0
  [3.5.5]: https://gitlab.com/cobib/cobib/-/tags/v3.5.5
  [3.5.4]: https://gitlab.com/cobib/cobib/-/tags/v3.5.4
  [3.5.3]: https://gitlab.com/cobib/cobib/-/tags/v3.5.3
  [3.5.2]: https://gitlab.com/cobib/cobib/-/tags/v3.5.2
  [3.5.1]: https://gitlab.com/cobib/cobib/-/tags/v3.5.1
  [3.5.0]: https://gitlab.com/cobib/cobib/-/tags/v3.5.0
  [3.4.0]: https://gitlab.com/cobib/cobib/-/tags/v3.4.0
  [3.3.2]: https://gitlab.com/cobib/cobib/-/tags/v3.3.2
  [3.3.1]: https://gitlab.com/cobib/cobib/-/tags/v3.3.1
  [3.3.0]: https://gitlab.com/cobib/cobib/-/tags/v3.3.0
  [3.2.1]: https://gitlab.com/cobib/cobib/-/tags/v3.2.1
  [3.2.0]: https://gitlab.com/cobib/cobib/-/tags/v3.2.0
  [3.1.1]: https://gitlab.com/cobib/cobib/-/tags/v3.1.1
  [3.1.0]: https://gitlab.com/cobib/cobib/-/tags/v3.1.0
  [3.0.0]: https://gitlab.com/cobib/cobib/-/tags/v3.0.0
  [2.6.1]: https://gitlab.com/cobib/cobib/-/tags/v2.6.1
  [2.6.0]: https://gitlab.com/cobib/cobib/-/tags/v2.6.0
  [2.5.0]: https://gitlab.com/cobib/cobib/-/tags/v2.5.0
  [2.4.1]: https://gitlab.com/cobib/cobib/-/tags/v2.4.1
  [2.4.0]: https://gitlab.com/cobib/cobib/-/tags/v2.4.0
  [2.3.4]: https://gitlab.com/cobib/cobib/-/tags/v2.3.4
  [2.3.3]: https://gitlab.com/cobib/cobib/-/tags/v2.3.3
  [2.3.2]: https://gitlab.com/cobib/cobib/-/tags/v2.3.2
  [2.3.1]: https://gitlab.com/cobib/cobib/-/tags/v2.3.1
  [2.3.0]: https://gitlab.com/cobib/cobib/-/tags/v2.3.0
  [2.2.2]: https://gitlab.com/cobib/cobib/-/tags/v2.2.2
  [2.2.1]: https://gitlab.com/cobib/cobib/-/tags/v2.2.1
  [2.2.0]: https://gitlab.com/cobib/cobib/-/tags/v2.2.0
  [2.1.0]: https://gitlab.com/cobib/cobib/-/tags/v2.1.0
  [2.0.0]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0
  [2.0.0b4]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b4
  [2.0.0b3]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b3
  [2.0.0b2]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b2
  [2.0.0b1]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b1
  [2.0.0b0]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0b0
  [2.0.0a2]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0a2
  [2.0.0a1]: https://gitlab.com/cobib/cobib/-/tags/v2.0.0a1
  [1.1.0]: https://gitlab.com/cobib/cobib/-/tags/v1.1.0
  [1.0.2]: https://gitlab.com/cobib/cobib/-/tags/v1.0.2
  [1.0.1]: https://gitlab.com/cobib/cobib/-/tags/v1.0.1
  [1.0.0]: https://gitlab.com/cobib/cobib/-/tags/v1.0.0
  [0.2]: https://gitlab.com/cobib/cobib/-/tags/v0.2
  [0.1]: https://gitlab.com/cobib/cobib/-/tags/v0.1


pkgId: 1dba2a33fa5af039ab968590f916c8dcd3ef05ded60cb0014e8e102c788f0b23
name: python-coconut-pytorch-help
arch: noarch
version: 0.0.20
epoch: 0
release: 1
summary: Development documents and examples for coconut-pytorch
url: https://pypi.org/project/coconut-pytorch/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coconut-pytorch-0.0.20-1.src.rpm
location_href: Packages/python-coconut-pytorch-help-0.0.20-1.noarch.rpm
checksum_type: sha256
description:
  <img src="./coconut.png" width="400px"></img>



  Implementation of Coconut, proposed by the paper <a href="https://arxiv.org/abs/2412.06769">Training Large Language Models to Reason in a Continuous Latent Space</a> out of FAIR, in Pytorch

  Architecture wise, the closest work to the one proposed here would be <a href="https://github.com/lucidrains/recurrent-memory-transformer-pytorch">RMT</a>, where the memory tokens there could serve as the continuous latent tokens. Both directions are worth exploring



  ```bash
  $ pip install coconut-pytorch
  ```



  ```python
  import torch
  from coconut_pytorch import Coconut

  model = Coconut(
      num_reasoning_steps = 3,
      num_latents_per_step = 1,
      transformer = dict(
          num_tokens = 256,
          dim = 512,
          depth = 6
      )
  )

  prompt = torch.randint(0, 256, (2, 1024))
  answer = torch.randint(0, 256, (2, 64))

  loss = model(prompt, answer)
  loss.backward()



  answer = model.generate(prompt, max_length = 64) # (2, 64)
  ```



  ```bibtex
  @inproceedings{Hao2024TrainingLL,
      title   = {Training Large Language Models to Reason in a Continuous Latent Space},
      author  = {Shibo Hao and Sainbayar Sukhbaatar and DiJia Su and Xian Li and Zhiting Hu and Jason Weston and Yuandong Tian},
      year    = {2024},
      url     = {https://api.semanticscholar.org/CorpusID:274610816}
  }
  ```

  ```bibtex
  @article{Burtsev2021MultiStreamT,
      title   = {Multi-Stream Transformers},
      author  = {Mikhail S. Burtsev and Anna Rumshisky},
      journal = {ArXiv},
      year    = {2021},
      volume  = {abs/2107.10342},
      url     = {https://api.semanticscholar.org/CorpusID:236171087}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Phil Wang  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: deeec8e8a3f1fb2a433eba6c8b41c0d0f6391f70e1a7d1662492db2e64e5624a
name: python-coconut-pytorch-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for coconut-pytorch
url: https://pypi.org/project/coconut-pytorch/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coconut-pytorch-0.0.4-1.src.rpm
location_href: Packages/python-coconut-pytorch-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  <img src="./coconut.png" width="400px"></img>



  Implementation of Coconut, proposed by the paper <a href="https://arxiv.org/abs/2412.06769">Training Large Language Models to Reason in a Continuous Latent Space</a> out of FAIR, in Pytorch

  Architecture wise, the closest work to the one proposed here would be <a href="https://github.com/lucidrains/recurrent-memory-transformer-pytorch">RMT</a>, where the memory tokens there could serve as the continuous latent tokens. Both directions are worth exploring



  ```bash
  $ pip install coconut-pytorch
  ```



  ```python
  import torch
  from coconut_pytorch import Coconut

  model = Coconut(
      num_reasoning_steps = 3,
      transformer = dict(
          num_tokens = 256,
          dim = 512,
          depth = 2
      )
  )

  prompt = torch.randint(0, 256, (1, 1024))
  answer = torch.randint(0, 256, (1, 64))

  loss, (prompt_logits, reasoning_tokens, answer_logits) = model(prompt, answer)

  loss.backward()

  ```



  ```bibtex
  @inproceedings{Hao2024TrainingLL,
      title   = {Training Large Language Models to Reason in a Continuous Latent Space},
      author  = {Shibo Hao and Sainbayar Sukhbaatar and DiJia Su and Xian Li and Zhiting Hu and Jason Weston and Yuandong Tian},
      year    = {2024},
      url     = {https://api.semanticscholar.org/CorpusID:274610816}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Phil Wang  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: 7a54abe07ed181dcf6863cf015a1ca485498434403ce1ddf1f762c8e1eec3dd8
name: python-cocotbext-apb-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for cocotbext-apb
url: https://github.com/daxzio/cocotbext-apb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cocotbext-apb-0.0.1-1.src.rpm
location_href: Packages/python-cocotbext-apb-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/daxzio/cocotbext-apb/workflows/Regression%20Tests/badge.svg?branch=main)](https://github.com/daxzio/cocotbext-apb/actions/)
  [![codecov](https://codecov.io/gh/daxzio/cocotbext-apb/branch/main/graph/badge.svg)](https://codecov.io/gh/daxzio/cocotbext-apb)
  [![PyPI version](https://badge.fury.io/py/cocotbext-apb.svg)](https://pypi.org/project/cocotbext-apb)
  [![Downloads](https://pepy.tech/badge/cocotbext-apb)](https://pepy.tech/project/cocotbext-apb)

  GitHub repository: https://github.com/daxzio/cocotbext-apb



  APB simulation models for [cocotb](https://github.com/cocotb/cocotb).



  Installation from git (latest development version, potentially unstable):

      $ pip install https://github.com/daxzio/cocotbext-apb/archive/main.zip

  Installation for active development:

      $ git clone https://github.com/daxzio/cocotbext-apb
      $ pip install -e cocotbext-apb



  See the `tests` directory for complete testbenches using these modules.



  The `APBBus` is used to map to a JTAG interface on the `dut`.  These hold instances of bus objects for the individual channels, which are currently extensions of `cocotb_bus.bus.Bus`.  Class methods `from_entity` and `from_prefix` are provided to facilitate signal default name matching.


  * _psel_
  * _pwrite_
  * _paddr_
  * _pwdata_
  * _pready_
  * _prdata_


  * _pstrb_
  * _pprot_
  * _pslverr_


pkgId: 0774158d96794b132df64b29bf40bf364e658d66ef76bee9a1e763037ff39290
name: python-codat-bankfeeds-help
arch: noarch
version: 10.0.0
epoch: 0
release: 1
summary: Development documents and examples for codat-bankfeeds
url: https://github.com/codatio/client-sdk-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codat-bankfeeds-10.0.0-1.src.rpm
location_href: Packages/python-codat-bankfeeds-help-10.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- Start Codat Tags Table -->

  | Endpoints | Description |
  | :- |:- |
  | Companies | Create and manage your SMB users' companies. |
  | Connections | Create new and manage existing data connections for a company. |
  | Source accounts | Provide and manage lists of source bank accounts. |
  | Account mapping | Extra functionality for building an account management UI. |
  | Company information | Get detailed information about a company from the underlying platform. |
  | Transactions | Create new bank account transactions for a company's connections, and see previous operations. |
  <!-- End Codat Tags Table -->
  <!-- End Summary [summary] -->
  <!-- Start Table of Contents [toc] -->

  <!-- $toc-max-depth=2 -->
  * [Bank Feeds](https://github.com/codatio/client-sdk-python/blob/master/#bank-feeds)
    * [Endpoints](https://github.com/codatio/client-sdk-python/blob/master/#endpoints)
    * [SDK Installation](https://github.com/codatio/client-sdk-python/blob/master/#sdk-installation)
    * [Example Usage](https://github.com/codatio/client-sdk-python/blob/master/#example-usage)
    * [IDE Support](https://github.com/codatio/client-sdk-python/blob/master/#ide-support)
    * [SDK Example Usage](https://github.com/codatio/client-sdk-python/blob/master/#sdk-example-usage)
    * [Available Resources and Operations](https://github.com/codatio/client-sdk-python/blob/master/#available-resources-and-operations)
    * [File uploads](https://github.com/codatio/client-sdk-python/blob/master/#file-uploads)
    * [Retries](https://github.com/codatio/client-sdk-python/blob/master/#retries)
    * [Error Handling](https://github.com/codatio/client-sdk-python/blob/master/#error-handling)
    * [Server Selection](https://github.com/codatio/client-sdk-python/blob/master/#server-selection)
    * [Custom HTTP Client](https://github.com/codatio/client-sdk-python/blob/master/#custom-http-client)
    * [Authentication](https://github.com/codatio/client-sdk-python/blob/master/#authentication)
    * [Debugging](https://github.com/codatio/client-sdk-python/blob/master/#debugging)
    * [Support](https://github.com/codatio/client-sdk-python/blob/master/#support)
  <!-- End Table of Contents [toc] -->
  <!-- Start SDK Installation [installation] -->

  The SDK can be installed with either *pip* or *poetry* package managers.

  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.
  ```bash
  pip install codat-bankfeeds
  ```

  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.
  ```bash
  poetry add codat-bankfeeds
  ```
  <!-- End SDK Installation [installation] -->

  <!-- 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] -->
  <!-- Start SDK Example Usage [usage] -->


  ```python

  from codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  from decimal import Decimal
  with CodatBankFeeds() as codat_bank_feeds:
      codat_bank_feeds.bank_feeds_source_account_connected(request={
          "event_type": "bankFeeds.sourceAccount.connected",
          "generated_date": "2022-10-23T00:00:00Z",
          "id": "ba29118f-5406-4e59-b05c-ba307ca38d01",
          "payload": {
              "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
              "reference_company": {
                  "description": "Requested early access to the new financing scheme.",
                  "id": "0498e921-9b53-4396-a412-4f2f5983b0a2",
                  "links": {
                      "portal": "https://app.codat.io/companies/0498e921-9b53-4396-a412-4f2f5983b0a2/summary",
                  },
                  "name": "Toft stores",
              },
              "source_account": {
                  "id": "acc-002",
                  "account_name": "account-081",
                  "account_number": "12345678",
                  "balance": Decimal("99.99"),
                  "currency": "GBP",
                  "modified_date": "2023-01-09T14:14:14.105Z",
                  "sort_code": "040004",
                  "status": shared.Status.PENDING,
              },
          },
      })
      
  ```
  </br>
  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  from decimal import Decimal
  async def main():
      async with CodatBankFeeds() as codat_bank_feeds:
          await codat_bank_feeds.bank_feeds_source_account_connected_async(request={
              "event_type": "bankFeeds.sourceAccount.connected",
              "generated_date": "2022-10-23T00:00:00Z",
              "id": "ba29118f-5406-4e59-b05c-ba307ca38d01",
              "payload": {
                  "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
                  "reference_company": {
                      "description": "Requested early access to the new financing scheme.",
                      "id": "0498e921-9b53-4396-a412-4f2f5983b0a2",
                      "links": {
                          "portal": "https://app.codat.io/companies/0498e921-9b53-4396-a412-4f2f5983b0a2/summary",
                      },
                      "name": "Toft stores",
                  },
                  "source_account": {
                      "id": "acc-002",
                      "account_name": "account-081",
                      "account_number": "12345678",
                      "balance": Decimal("99.99"),
                      "currency": "GBP",
                      "modified_date": "2023-01-09T14:14:14.105Z",
                      "sort_code": "040004",
                      "status": shared.Status.PENDING,
                  },
              },
          })
          
  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->
  <!-- Start Available Resources and Operations [operations] -->

  <details open>
  <summary>Available methods</summary>

  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accountmapping/README.md#create) - Create bank feed account mapping
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/accountmapping/README.md#get) - List bank feed accounts

  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#create) - Create bank account
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#get_create_model) - Get create/update bank account model
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/bankaccounts/README.md#list) - List bank accounts

  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companies/README.md#create) - Create company
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companies/README.md#delete) - Delete a company
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companies/README.md#get) - Get company
  * [get_access_token](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companies/README.md#get_access_token) - Get company access token
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companies/README.md#list) - List companies
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companies/README.md#update) - Update company

  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/companyinformation/README.md#get) - Get company information

  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/configuration/README.md#get) - Get configuration
  * [set](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/configuration/README.md#set) - Set configuration

  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/connections/README.md#create) - Create connection
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/connections/README.md#delete) - Delete connection
  * [get](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/connections/README.md#get) - Get connection
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/connections/README.md#list) - List connections
  * [unlink](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/connections/README.md#unlink) - Unlink connection

  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#create) - Create single source account
  * [create_batch](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#create_batch) - Create source accounts
  * [delete](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#delete) - Delete source account
  * [delete_credentials](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#delete_credentials) - Delete all source account credentials
  * [generate_credentials](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#generate_credentials) - Generate source account credentials
  * [list](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#list) - List source accounts
  * [update](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sourceaccounts/README.md#update) - Update source account

  * [get_last_successful_sync](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/sync/README.md#get_last_successful_sync) - Get last successful sync

  * [create](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transactions/README.md#create) - Create bank transactions
  * [get_create_model](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transactions/README.md#get_create_model) - Get create bank transactions model
  * [get_create_operation](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transactions/README.md#get_create_operation) - Get create operation
  * [list_create_operations](https://github.com/codatio/client-sdk-python/blob/master/docs/sdks/transactions/README.md#list_create_operations) - List create operations
  </details>
  <!-- End Available Resources and Operations [operations] -->
  <!-- Start File uploads [file-upload] -->

  Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.
  > [!TIP]
  >
  > For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.
  >
  ```python
  from codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  with CodatBankFeeds(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  ) as codat_bank_feeds:
      res = codat_bank_feeds.source_accounts.generate_credentials(request={
          "request_body": open("example.file", "rb"),
          "company_id": "8a210b68-6988-11ed-a1eb-0242ac120002",
          "connection_id": "2e9d2c44-f675-40ba-8049-353bfcb5e171",
      })
      assert res is not None
      
      print(res)
  ```
  <!-- End File uploads [file-upload] -->
  <!-- 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 codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  from codat_bankfeeds.utils import BackoffStrategy, RetryConfig
  with CodatBankFeeds(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  ) as codat_bank_feeds:
      res = codat_bank_feeds.companies.create(request={
          "name": "Technicalium",
          "description": "Requested early access to the new financing scheme.",
      },
          RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))
      assert res is not None
      
      print(res)
  ```
  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 codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  from codat_bankfeeds.utils import BackoffStrategy, RetryConfig
  with CodatBankFeeds(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  ) as codat_bank_feeds:
      res = codat_bank_feeds.companies.create(request={
          "name": "Technicalium",
          "description": "Requested early access to the new financing scheme.",
      })
      assert res is not None
      
      print(res)
  ```
  <!-- End Retries [retries] -->
  <!-- Start Error Handling [errors] -->

  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.
  By default, an API error will raise a errors.SDKError exception, which has the following properties:
  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |
  When custom error responses are specified for an operation, the SDK may also raise their associated exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `create_async` method may raise the following exceptions:
  | Error Type          | Status Code                       | Content Type     |
  | ------------------- | --------------------------------- | ---------------- |
  | errors.ErrorMessage | 400, 401, 402, 403, 429, 500, 503 | application/json |
  | errors.SDKError     | 4XX, 5XX                          | \*/\*            |

  ```python
  from codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import errors, shared
  with CodatBankFeeds(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  ) as codat_bank_feeds:
      res = None
      try:
          res = codat_bank_feeds.companies.create(request={
              "name": "Technicalium",
              "description": "Requested early access to the new financing scheme.",
          })
          assert res is not None
          
          print(res)
      except errors.ErrorMessage as e:
          
          raise(e)
      except errors.SDKError as e:
          
          raise(e)
  ```
  <!-- End Error Handling [errors] -->
  <!-- Start Server Selection [server] -->


  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 codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  with CodatBankFeeds(
      server_url="https://api.codat.io",
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  ) as codat_bank_feeds:
      res = codat_bank_feeds.companies.create(request={
          "name": "Technicalium",
          "description": "Requested early access to the new financing scheme.",
      })
      assert res is not None
      
      print(res)
  ```
  <!-- 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 codat_bankfeeds import CodatBankFeeds
  import httpx
  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = CodatBankFeeds(client=http_client)
  ```
  or you could wrap the client with your own custom logic:
  ```python
  from codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.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 = CodatBankFeeds(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  |
  | ------------- | ------ | ------- |
  | `auth_header` | apiKey | API key |
  You can set the security parameters through the `security` optional parameter when initializing the SDK client instance. For example:
  ```python
  from codat_bankfeeds import CodatBankFeeds
  from codat_bankfeeds.models import shared
  with CodatBankFeeds(
      security=shared.Security(
          auth_header="Basic BASE_64_ENCODED(API_KEY)",
      ),
  ) as codat_bank_feeds:
      res = codat_bank_feeds.companies.create(request={
          "name": "Technicalium",
          "description": "Requested early access to the new financing scheme.",
      })
      assert res is not None
      
      print(res)
  ```
  <!-- End Authentication [security] -->
  <!-- Start Debugging [debug] -->

  You can setup your SDK to emit debug logs for SDK requests and responses.
  You can pass your own logger class directly into your SDK.
  ```python
  from codat_bankfeeds import CodatBankFeeds
  import logging
  logging.basicConfig(level=logging.DEBUG)
  s = CodatBankFeeds(debug_logger=logging.getLogger("codat_bankfeeds"))
  ```
  <!-- End Debugging [debug] -->
  <!-- Placeholder for Future Speakeasy SDK Sections -->
  <!-- Start Codat Support Notes -->

  If you encounter any challenges while utilizing our SDKs, please don't hesitate to reach out for assistance.
  You can raise any issues by contacting your dedicated Codat representative or reaching out to our [support team](https://github.com/codatio/client-sdk-python/blob/master/mailto:support@codat.io).
  We're here to help ensure a smooth experience for you.
  <!-- End Codat Support Notes -->
  <!-- Start Codat Generated By -->

  <!-- End Codat Generated By -->


pkgId: 8d026406f3936efda02c3a7864a99f2251aefa51452e7d4e800ffc9c0b579840
name: python-code-beautifyer-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for code-beautifyer
url: https://pypi.org/project/code-beautifyer/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-code-beautifyer-1.0.0-1.src.rpm
location_href: Packages/python-code-beautifyer-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Automatic Code Formatting**: Ensures your code adheres to best practices.
  - **Multi-Language Support**: Works with Python, JavaScript, HTML, and more.
  - **Customizable Rules**: Define your own formatting preferences.
  - **Error-Free Indentation**: Fixes inconsistent indentation and spacing.


pkgId: 63d5334e6b734e2363f521f16bdef07a34b7d419d70a6c5a8d872174fa43bb6f
name: python-code-tracker-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for code-tracker
url: https://pypi.org/project/code-tracker/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-code-tracker-1.0.0-1.src.rpm
location_href: Packages/python-code-tracker-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/code-tracker.svg)](https://badge.fury.io/py/code-tracker)

  `code-tracker` is a Python package designed to help developers track changes and monitor the history of their code. It provides tools for versioning, tracking modifications, and analyzing code changes over time, making it an essential tool for development workflows.



  - **Version Tracking**: Keep track of code changes with detailed version history.
  - **Diff Analysis**: Compare different versions of code to identify changes.
  - **Customizable Hooks**: Add hooks to execute tasks on code changes.
  - **Integration Ready**: Seamlessly integrates with Git and other version control systems.



  Install `code-tracker` using pip:

  ```bash
  pip install code-tracker
  ```



  Here's a basic example to get started:

  ```python
  from code_tracker import CodeTracker


  tracker = CodeTracker("/path/to/your/code")


  tracker.track_changes()


  history = tracker.get_history()
  print(history)


  diff = tracker.compare_versions("file.py", version1="v1.0", version2="v2.0")
  print(diff)
  ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a new branch for your feature: `git checkout -b feature-name`.
  3. Commit your changes: `git commit -m 'Add some feature'`.
  4. Push to the branch: `git push origin feature-name`.
  5. Open a pull request.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.



  If you have any questions or feedback, feel free to reach out to [Your Email or GitHub Profile].


pkgId: 159df40bef2e55193f2f929f563e6fecd692c2fbaff77d0ae2524c20404ec3e2
name: python-codecarbon-help
arch: noarch
version: 2.8.2
epoch: 0
release: 1
summary: Development documents and examples for codecarbon
url: https://codecarbon.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codecarbon-2.8.2-1.src.rpm
location_href: Packages/python-codecarbon-help-2.8.2-1.noarch.rpm
checksum_type: sha256
description:
  ![banner](docs/edit/images/banner.png)

  Estimate and track carbon emissions from your computer, quantify and analyze their impact.

  [**Documentation**](https://mlco2.github.io/codecarbon)

  <br/>

  [![](https://anaconda.org/conda-forge/codecarbon/badges/version.svg)](https://anaconda.org/conda-forge/codecarbon)
  [![](https://anaconda.org/codecarbon/codecarbon/badges/version.svg)](https://anaconda.org/codecarbon/codecarbon)
  [![](https://img.shields.io/pypi/v/codecarbon?color=024758)](https://pypi.org/project/codecarbon/)
  [![DOI](https://zenodo.org/badge/263364731.svg)](https://zenodo.org/badge/latestdoi/263364731)
  [![Downloads](https://static.pepy.tech/badge/codecarbon/month)](https://pepy.tech/project/codecarbon)


  - [About CodeCarbon 💡](#about-codecarbon-)
  - [Quickstart 🚀](#quickstart-)
      - [Installation 🔧](#installation-)
      - [Start to estimate your impact 📏](#start-to-estimate-your-impact-)
        - [Monitoring your whole machine](#monitoring-your-machine-)
        - [In your python code](#in-your-python-code-)
        - [Visualize](#visualize-)
  - [Contributing 🤝](#contributing-)
  - [How To Cite 📝](#how-to-cite-)
  - [Contact 📝](#contact-)



  **CodeCarbon** started with a quite simple question:

  **What is the carbon emission impact of my computer program? :shrug:**

  We found some global data like "computing currently represents roughly 0.5% of the world’s energy consumption" but nothing on our individual/organisation level impact.

  At **CodeCarbon**, we believe, along with Niels Bohr, that "Nothing exists until it is measured". So we found a way to estimate how much CO<sub>2</sub> we produce while running our code.

  *How?*

  We created a Python package that estimates your hardware electricity power consumption (GPU + CPU + RAM) and we apply to it the carbon intensity of the region where the computing is done.

  ![calculation Summary](docs/edit/images/calculation.png)

  We explain more about this calculation in the [**Methodology**](https://mlco2.github.io/codecarbon/methodology.html#) section of the documentation.

  Our hope is that this package will be used widely for estimating the carbon footprint of computing, and for establishing best practices with regards to the disclosure and reduction of this footprint.

  **So ready to "change the world one run at a time"? Let's start with a very quick set up.**





  **From PyPI repository**
  ```python
  pip install codecarbon
  ```

  **From Conda repository**
  ```python
  conda install -c codecarbon codecarbon
  ```
  To see more installation options please refer to the documentation: [**Installation**](https://mlco2.github.io/codecarbon/installation.html#)



  To get an experiment_id enter:
  ```python
  ! codecarbon init
  ```
  You can now store it in a **.codecarbon.config** at the root of your project
  ```python
  [codecarbon]
  log_level = DEBUG
  save_to_api = True
  experiment_id = 2bcbcbb8-850d-4692-af0d-76f6f36d79b2 #the experiment_id you get with init
  ```
  Now you have 2 main options:



  In your command prompt use:
  ```codecarbon monitor```
  The package will track your emissions independently from your code.


  ```python
  from codecarbon import track_emissions
  @track_emissions()
  def your_function_to_track():
    
    ```
  The package will track the emissions generated by the execution of your function.

  There is other ways to use **codecarbon** package, please refer to the documentation to learn more about it:  [**Usage**](https://mlco2.github.io/codecarbon/usage.html#)



  You can now visualize your experiment emissions on the [dashboard](https://dashboard.codecarbon.io/).
  ![dashboard](docs/edit/images/dashboard.png)

  *Note that for now, all emissions data send to codecarbon API are public.*

  > Hope you enjoy your first steps monitoring your carbon computing impact!
  > Thanks to the incredible codecarbon community 💪🏼 a lot more options are available using *codecarbon* including:
  > - offline mode
  > - cloud mode
  > - comet integration...
  >
  > Please explore the [**Documentation**](https://mlco2.github.io/codecarbon) to learn about it
  > If ever what your are looking for is not yet implemented, let us know through the *issues* and even better become one of our 🦸🏼‍♀️🦸🏼‍♂️ contributors! more info 👇🏼




  We are hoping that the open-source community will help us edit the code and make it better!

  You are welcome to open issues, even suggest solutions and better still contribute the fix/improvement! We can guide you if you're not sure where to start but want to help us out 🥇

  In order to contribute a change to our code base, please submit a pull request (PR) via GitHub and someone from our team will go over it and accept it.

  Check out our [contribution guidelines :arrow_upper_right:](https://github.com/mlco2/codecarbon/blob/master/CONTRIBUTING.md)

  Contact [@vict0rsch](https://github.com/vict0rsch) to be added to our slack workspace if you want to contribute regularly!



  If you find CodeCarbon useful for your research, you can find a citation under a variety of formats on [Zenodo](https://zenodo.org/records/11171501).

  Here is a sample for BibTeX:
  ```tex
  @software{benoit_courty_2024_11171501,
    author       = {Benoit Courty and
                    Victor Schmidt and
                    Sasha Luccioni and
                    Goyal-Kamal and
                    MarionCoutarel and
                    Boris Feld and
                    Jérémy Lecourt and
                    LiamConnell and
                    Amine Saboni and
                    Inimaz and
                    supatomic and
                    Mathilde Léval and
                    Luis Blanche and
                    Alexis Cruveiller and
                    ouminasara and
                    Franklin Zhao and
                    Aditya Joshi and
                    Alexis Bogroff and
                    Hugues de Lavoreille and
                    Niko Laskaris and
                    Edoardo Abati and
                    Douglas Blank and
                    Ziyao Wang and
                    Armin Catovic and
                    Marc Alencon and
                    Michał Stęchły and
                    Christian Bauer and
                    Lucas Otávio N. de Araújo and
                    JPW and
                    MinervaBooks},
    title        = {mlco2/codecarbon: v2.4.1},
    month        = may,
    year         = 2024,
    publisher    = {Zenodo},
    version      = {v2.4.1},
    doi          = {10.5281/zenodo.11171501},
    url          = {https://doi.org/10.5281/zenodo.11171501}
  }
  ```



  Maintainers are [@vict0rsch](https://github.com/vict0rsch) [@benoit-cty](https://github.com/benoit-cty) and [@SaboniAmine](https://github.com/saboniamine). Codecarbon is developed by volunteers from [**Mila**](http://mila.quebec) and the [**DataForGoodFR**](https://twitter.com/dataforgood_fr) community alongside donated professional time of engineers at [**Comet.ml**](https://comet.ml) and [**BCG GAMMA**](https://www.bcg.com/en-nl/beyond-consulting/bcg-gamma/default).


pkgId: e30c653f7fc0007e00862efbc3643ae243749b39ce2adb7468ff403aead8fe0f
name: python-codeflare-sdk-help
arch: noarch
version: 0.24.3
epoch: 0
release: 1
summary: Development documents and examples for codeflare-sdk
url: https://github.com/project-codeflare/codeflare-sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codeflare-sdk-0.24.3-1.src.rpm
location_href: Packages/python-codeflare-sdk-help-0.24.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Python application](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/unit-tests.yml/badge.svg?branch=main)](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/unit-tests.yml)
  ![coverage badge](./coverage.svg)

  An intuitive, easy-to-use python interface for batch resource requesting, access, job submission, and observation. Simplifying the developer's life while enabling access to high-performance compute resources, either in the cloud or on-prem.

  For guided demos and basics walkthroughs, check out the following links:

  - Guided demo notebooks available [here](https://github.com/project-codeflare/codeflare-sdk/tree/main/demo-notebooks/guided-demos), and copies of the notebooks with [expected output](https://github.com/project-codeflare/codeflare-sdk/tree/main/demo-notebooks/guided-demos/notebook-ex-outputs) also available
  - these demos can be copied into your current working directory when using the `codeflare-sdk` by using the `codeflare_sdk.copy_demo_nbs()` function
  - Additionally, we have a [video walkthrough](https://www.youtube.com/watch?v=U76iIfd9EmE) of these basic demos from June, 2023

  Full documentation can be found [here](https://project-codeflare.github.io/codeflare-sdk/index.html)



  Can be installed via `pip`: `pip install codeflare-sdk`



  Please see our [CONTRIBUTING.md](./CONTRIBUTING.md) for detailed instructions.





  It is possible to use the Release Github workflow to do the release. This is generally the process we follow for releases



  The following instructions apply when doing release manually. This may be required in instances where the automation is failing.

  - Check and update the version in "pyproject.toml" file.
  - Commit all the changes to the repository.
  - Create Github release (<https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release>).
  - Build the Python package. `poetry build`
  - If not present already, add the API token to Poetry.
  `poetry config pypi-token.pypi API_TOKEN`
  - Publish the Python package. `poetry publish`
  - Trigger the [Publish Documentation](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/publish-documentation.yaml) workflow


pkgId: 648e7e1790fe4b5d9d2d205927cfa1a5ec8f547481be01570b988d0d4ce4db80
name: python-codelimit-help
arch: noarch
version: 0.14.1
epoch: 0
release: 1
summary: Development documents and examples for codelimit
url: https://pypi.org/project/codelimit/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codelimit-0.14.1-1.src.rpm
location_href: Packages/python-codelimit-help-0.14.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Logo](docs/logo.png)

  </div>

  <div align="center">

    *Your Refactoring Alarm 🔔*

  </div>

  <div align="center">

  [![main](https://github.com/getcodelimit/codelimit/actions/workflows/main.yml/badge.svg)](https://github.com/getcodelimit/codelimit/actions/workflows/main.yml)
  [![codecov](https://codecov.io/gh/getcodelimit/codelimit/branch/main/graph/badge.svg?token=ZQBEAJVC2Y)](https://codecov.io/gh/getcodelimit/codelimit)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Linting: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![codelimit](https://github.com/getcodelimit/codelimit/blob/_codelimit_reports/main/badge.svg?raw=true)](https://github.com/getcodelimit/codelimit/blob/_codelimit_reports/main/codelimit.md)

  </div>



  Code Limit is a tool for developers with one goal: _it tells the developer when
  it’s time to refactor_.

  Check out the [documentation](https://getcodelimit.github.io) and start
  using Code Limit today to keep your code maintainable.



  Depending on your development workflow, Code Limit can run in many different
  ways (e.g.: pre-commit hook, GitHub Action, standalone, etc.). See the
  [Quickstart documentation](https://getcodelimit.github.io/quickstart/) for
  examples.



  Code Limit can run as a standalone program to check and inspect a codebase, see
  the [Standalone Usage documentation](https://getcodelimit.github.io/usage/) to
  get started.



  Code Limit aims to be zero-configuration. However, sometimes the exception
  proves the rule. Check out the [Configuration
  documentation](https://getcodelimit.github.io/configuration/) for all
  configuration options.



  See the [Development
  documentation](https://getcodelimit.github.io/development) if you want to
  extend or contribute to Code Limit.



  If you have suggestions for how Code Limit could be improved, or want to report
  a bug, [open an issue](https://github.com/getcodelimit/codelimit/issues)! All
  and any contributions are appreciated.

  To show your project uses Code Limit place this badge in the README markdown:

  [![Checked with Code Limit](https://img.shields.io/badge/Code%20Limit-checked-green.svg)](https://github.com/getcodelimit/codelimit)

  ```
  ![Checked with Code Limit](https://img.shields.io/badge/Code%20Limit-checked-green.svg)](https://github.com/getcodelimit/codelimit)
  ```



  [GPL-3.0-or-later](LICENSE) © 2022 Rob van der Leek <robvanderleek@gmail.com>
  (https://twitter.com/robvanderleek)


pkgId: 4d5a7c330ec75f7768c7ef48e1591eba4632560fcce326254eca6b1c96985c95
name: python-codemodder-help
arch: noarch
version: 3.14.1
epoch: 0
release: 1
summary: Development documents and examples for codemodder
url: https://codemodder.io
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codemodder-3.14.1-1.src.rpm
location_href: Packages/python-codemodder-help-3.14.1-1.noarch.rpm
checksum_type: sha256
description:
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="img/codemodder-dark.png">
    <source media="(prefers-color-scheme: light)" srcset="img/codemodder-light.png">
    <img alt="Pixee Logo" src="https://github.com/pixee/pixee-cli/raw/main/img/codemodder.png">
  </picture>



  This is the Python version of the [Codemodder Framework](https://codemodder.io/).

  Codemodder is sponsored by [pixee.ai](https://pixee.ai).



  As of [v0.80.0](https://github.com/pixee/codemodder-python/releases/tag/0.80.0) the codemod API is relatively stable. However, backwards compatibility between releases will not be guaranteed until version 1.0.0.


  See [CHANGELOG.md](CHANGELOG.md) for detailed release notes.



  The `codemodder` package is available [on PyPI](https://pypi.org/project/codemodder/). To install, run:
  ```
  $ pip install codemodder
  ```

  To install the package from source, use `pip`:

  ```
  $ pip install /path/to/codemodder-python
  ```





  Codemodder can be run as a CLI. The codemodder package provides an executable called `codemodder`. This should be available on your path by default after installation.

  For basic usage, run the `codemodder` command with a target directory path:

  ```
  $ codemodder /path/to/my-project
  ```

  Note that by default `codemodder` will make changes to files in your target directory. To run `codemodder` without making updates on disk, use the `--dry-run` flag:
  ```
  $ codemodder --dry-run /path/to/my-project
  ```

  To list all available codemods (including any that are registered with installed plugins), use the `--list` option:
  ```
  $ codemodder --list
  ```

  For a full list of options, use the `--help` flag:
  ```
  $ codemodder --help
  ```



  You can also run `codemodder` as a library by importing the module and running `run`. For basic usage, pass a target directory path and the `dry_run` argument:

  ```python
  import codemodder

  output, exit_code = codemodder.run("/path/to/my-project", dry_run=True)
  ```

  Unlike the CLI which has a default `dry_run` of `False`, when calling `codemodder` as a library you must indicate if you want `codemodder` to make changes to your files.




  Codemods are composed of the following key components:
  * Detector
  * Transformer(s)
  * Metadata

  <picture>
    <source srcset="img/base-codemod.jpg">
    <img alt="Base Codemod Diagram" src="https://github.com/pixee/pixee-cli/raw/main/img/base-codemod.jpg">
  </picture>



  The Python codemodder supports a plugin infrastructure for custom codemods. For users interested in developing a custom codemod plugin, we recommend starting with the [Cookiecutter template](https://github.com/pixee/cookiecutter-codemodder-plugin).



  Coming soon!


  See [CONTRIBUTING.md](CONTRIBUTING.md).

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


pkgId: ae838ab9754dde1f77b6c99e747d8cb17eb7c7344c8443bc54cf01d3152871eb
name: python-codescope-help
arch: noarch
version: 0.2.4
epoch: 0
release: 1
summary: Development documents and examples for codescope
url: https://pypi.org/project/codescope/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codescope-0.2.4-1.src.rpm
location_href: Packages/python-codescope-help-0.2.4-1.noarch.rpm
checksum_type: sha256
description:
  <!--Scope lets you statically extract and query call graphs from a codebase.-->
  **A call graph generator designed for codebase RAG.** Uses a combination of LSP and AST parsing to achieve very high accuracy, even for dynamic languages.

  * Supports 6+ popular languages
    * JavaScript
    * Python
    * TypeScript
    * Rust
    * C#
    * Java
  * Can be used programmatically or via the command-line
  * Provides easy retrieval methods (e.g. `get_definition`, `get_references`, `get_call_stack`, etc.)

  Built in collaboration with Microsoft Research.



  ```bash
  > pip install codescope
  ```

  ```bash
  > uv add codescope
  ```



  TODO



  To run tests:
  ```pytest tests/scope```



  Apache 2.0

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024 Adrenaline AI, Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 33287abb2010c42f32eb540bb678aacb536e46ff39b8205892b3109fc87c1cc7
name: python-codon-bias-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for codon-bias
url: https://github.com/alondmnt/codon-bias
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-codon-bias-0.3.2-1.src.rpm
location_href: Packages/python-codon-bias-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  This package provides codon usage bias (CUB) analysis tools for genomic sequences, focusing on protein coding regions, translation efficiency and synonymous mutations. These include implementations of popular models from the past four decades of codon usage study, such as:

  - [Nucleotide and codon k-mer statistics (GC, GC3, CpG, etc.)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#module-codonbias.stats)
  - [Frequency of Optimal Codons (FOP)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.FrequencyOfOptimalCodons)
  - [Relative Synonymous Codon Usage (RSCU)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.RelativeSynonymousCodonUsage)
  - [Codon Adaptation Index (CAI)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.CodonAdaptationIndex), including extensions:
      - Codon pair (and k-mers) adaptation
  - [Effective Number of Codons (ENC)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.EffectiveNumberOfCodons), including extensions:
      - Background correction
      - Improved estimation
      - Effective number of codon pairs (and k-mers) (ENcp)
  - [tRNA Adaptation Index (tAI)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.TrnaAdaptationIndex)
      - Download tRNA gene copy numbers from [GtRNAdb](http://gtrnadb.ucsc.edu/)
      - Train tAI model parameters (s-values) using expression levels
  - [Codon Pair Bias (CPB/CPS)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.CodonPairBias)
  - [Relative Codon Bias Score (RCBS)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.RelativeCodonBiasScore)
  - [Normalized Translational Efficiency (nTE)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.NormalizedTranslationalEfficiency)
  - [Directional Codon Bias Score (DCBS)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.scores.RelativeCodonBiasScore)
  - [Codon Usage Frequency Similarity (CUFS)](https://codon-bias.readthedocs.io/en/latest/codonbias.html#codonbias.pairwise.CodonUsageFrequency)

  This package also includes tools for sequence optimization based on these codon usage models, and generators of random sequence permutations that can be used to compute empirical p-values and z-scores.



  ```
  pip install codon-bias
  ```



  Read on [Read the Docs](https://codon-bias.readthedocs.org).



  Diament, A. (2022). codon-bias (python package) (Version 0.3.0). https://doi.org/10.5281/zenodo.8039452



  Contributions of additional models to the package are welcome! Please familiarize yourself with the existing classes, and try to conform to their style.


pkgId: c84445f271431a565e8d93e905bc881c5fca2603f2cfeb7e11d5581fd90eddc0
name: python-cogflow-help
arch: noarch
version: 1.9.47
epoch: 0
release: 1
summary: Development documents and examples for cogflow
url: https://pypi.org/project/cogflow/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cogflow-1.9.47-1.src.rpm
location_href: Packages/python-cogflow-help-1.9.47-1.noarch.rpm
checksum_type: sha256
description:
  By setting the environment variables correctly, you can fully utilize the features and functionalities of the CogFlow framework for your cognitive and machine learning tasks.


pkgId: 338efdb86ba4a9ce4c0c1c7c73f305da387b55f8c56fbe02601ffc2266ff516d
name: python-cognite-neat-help
arch: noarch
version: 0.103.0
epoch: 0
release: 1
summary: Development documents and examples for cognite-neat
url: https://cognite-neat.readthedocs-hosted.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cognite-neat-0.103.0-1.src.rpm
location_href: Packages/python-cognite-neat-help-0.103.0-1.noarch.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/neat/release.yaml?style=for-the-badge)](https://github.com/cognitedata/neat/actions/workflows/release.yaml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-neat/badge/?version=latest&style=for-the-badge)](https://cognite-neat.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/neat-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/neat)
  [![PyPI](https://img.shields.io/pypi/v/cognite-neat?style=for-the-badge)](https://pypi.org/project/cognite-neat/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-neat?style=for-the-badge)](https://pypistats.org/packages/cognite-neat)
  [![Docker Pulls](https://img.shields.io/docker/pulls/cognite/neat?style=for-the-badge)](https://hub.docker.com/r/cognite/neat)
  [![GitHub](https://img.shields.io/github/license/cognitedata/neat?style=for-the-badge)](https://github.com/cognitedata/neat/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)

  NEAT is a domain expert centric and developer friendly solution for rapid:

  - semantic data modeling
  - creation, transformation and enrichment of knowledge graphs
  - and ingestion of the models and graphs into [Cognite Data Fusion](https://www.cognite.com/en/product/cognite_data_fusion_industrial_dataops_platform)

  NEAT is using open and globally recognized standards maintained by the [World Wide Web Consortium (W3C)](https://www.w3.org/RDF/).
  NEAT represents an essential tool for creation of standardized, machine-actionable, linked and semantic (meta)data.

  > NEAT is an acronym derived from k**N**owl**Ed**ge gr**A**ph **T**ransformer hallucinated by GenAI.



  ```bash
  pip install cognite-neat
  ```



  The user interface for `NEAT` is a notebook-based environment. Once you have set up your notebook
  environment, you start by creating a `CogniteClient` and instantiate a `NeatSession` object.

  ```python
  from cognite.neat import NeatSession, get_cognite_client

  client = get_cognite_client(".env")

  neat = NeatSession(client)

  neat.read.cdf.data_model(("my_space", "MyDataModel", "v1"))
  ```



  For more information, see the [documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)


pkgId: 9b7909133c50d9194fcb819049e7487818065222d1f36703e79aaeed7cf3d9d3
name: python-cognite-pygen-help
arch: noarch
version: 0.99.58
epoch: 0
release: 1
summary: Development documents and examples for cognite-pygen
url: https://cognite-pygen.readthedocs-hosted.com/en/latest/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cognite-pygen-0.99.58-1.src.rpm
location_href: Packages/python-cognite-pygen-help-0.99.58-1.noarch.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/pygen/release.yaml?style=for-the-badge)](https://github.com/cognitedata/pygen/actions/workflows/release.yaml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-pygen/badge/?version=latest&style=for-the-badge)](https://cognite-pygen.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/pygen-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/pygen)
  [![PyPI](https://img.shields.io/pypi/v/cognite-pygen?style=for-the-badge)](https://pypi.org/project/cognite-pygen/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-pygen?style=for-the-badge)](https://pypistats.org/packages/cognite-pygen)
  [![GitHub](https://img.shields.io/github/license/cognitedata/pygen?style=for-the-badge)](https://github.com/cognitedata/pygen/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)
  This is the Cognite Python SDK Generator, `pygen`. The purpose of this package is to help developers to
  work with Cognite Data Fusion's (CDF) Data Models (DM) in Python.
  **Beta Note** This package, `pygen`, is currently in beta, which is reflected in the version number `0.99.x`. Beta
  indicates that a product or functionality is in a mature testing phase, but is still subject to change or retirement.
  We will provide a deprecation notice a minimum of two months before retiring the product or functionality. We recommend
  not using the product or functionality in production systems.
  The core functionality is to provide a Python client that matches a data model. This enables the developer for the following
  benefits
  * Client-side validation of the data before writing it to CDF.
  * Autocompletion is matching the data model in the integrated developer environment (IDE). This is important as it enables:
    * Discoverability of a data model through Python.
    * Reduced typing errors in development.
  * Keeping the language domain specific for the developer. Instead of working with generic concepts such as instances,
    nodes and edges, the developer can work with the concepts in the data model.

  See the [documentation](https://cognite-pygen.readthedocs-hosted.com/en/latest/) for more information.


  To install this package without CLI support:
  ```bash
  pip install cognite-pygen
  ```

  * `cli` This includes CLI support such that you can run the package from the command line.
  ```bash
  pip install cognite-pygen[cli]
  ```
  If using zsh:
  ```bash
  pip install 'cognite-pygen[cli]'
  ```

  The goal of the package is to have representations of all the types in a given data model with API calls to *.list()*,
  *.apply()*, *.delete()*, and *.retrieve()* individuals for each type.
  ![image](https://github.com/cognitedata/pygen/assets/60234212/b9942595-424c-4c5e-8a9c-37a43e0a5a7c)
  ![image](https://github.com/cognitedata/pygen/assets/60234212/70a5f6b0-cec0-4178-93e1-4f9902658638)

  Given a Data Model with external id `Movie` in the space `movies` in CDF, the following command will generate a Python SDK
  ```bash
  pygen generate --space movies \
      --external-id Movie \
      --version 1 \
      --tenant-id <tenant-id> \
      --client-id <client-id> \
      --client-secret <client-secret> \
      --cdf-cluster <cdf-cluster> \
      --cdf-project <cdf-project>
  ```
  If you are not using Microsoft Entra ID (Azure AD) you need to specify the parameter --token-url, --scopes and --audience instead of --tenant-id.


  * [cognite-sdk](https://cognite-sdk-python.readthedocs-hosted.com/en/latest/) This is the basis for all requests to the Cognite Data Fusion API.
  * [pydantic](https://docs.pydantic.dev/latest/) This is used for all data classes in the generated SDK.
  * [pandas](https://pandas.pydata.org/docs/) This is used for `.to_pandas()` methods in the generated SDK.

  * [jinja2](https://jinja.palletsprojects.com/en/3.1.x/) This is used for the templating of the generated SDK.
  * [inflect](https://pypi.org/project/inflect/) This is used for the singularization/pluralization of words in the generated SDK.
  * [typer](https://typer.tiangolo.com/) (Optional) This is used for the CLI of the `pygen` package.
  * [black](https://pypi.org/project/black/) (Optional) This is used to format the code generated by the `pygen` package.

  Wondering about previous changes to the SDK? Take a look at the [CHANGELOG](https://github.com/cognitedata/pygen/blob/master/docs/CHANGELOG.md).

  Want to contribute? Check out [CONTRIBUTING](https://github.com/cognitedata/pygen/blob/master/CONTRIBUTING.md).


pkgId: 93ab5748e77b5e078649cda08c00f0cf2d5face0b800f23cea3bb3d16bc273b0
name: python-cognite-sdk-help
arch: noarch
version: 7.70.6
epoch: 0
release: 1
summary: Development documents and examples for cognite-sdk
url: https://pypi.org/project/cognite-sdk/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cognite-sdk-7.70.6-1.src.rpm
location_href: Packages/python-cognite-sdk-help-7.70.6-1.noarch.rpm
checksum_type: sha256
description:
  [![build](https://github.com/cognitedata/cognite-sdk-python/workflows/release/badge.svg)](https://github.com/cognitedata/cognite-sdk-python/actions?query=workflow:release)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-sdk)](https://pypistats.org/packages/cognite-sdk)
  [![GitHub](https://img.shields.io/github/license/cognitedata/cognite-sdk-python)](https://github.com/cognitedata/cognite-sdk-python/blob/master/LICENSE)
  [![codecov](https://codecov.io/gh/cognitedata/cognite-sdk-python/branch/master/graph/badge.svg)](https://codecov.io/gh/cognitedata/cognite-sdk-python)
  [![Documentation Status](https://readthedocs.com/projects/cognite-sdk-python/badge/?version=latest)](https://cognite-sdk-python.readthedocs-hosted.com/en/latest/)
  [![PyPI version](https://badge.fury.io/py/cognite-sdk.svg)](https://pypi.org/project/cognite-sdk/)
  [![conda version](https://anaconda.org/conda-forge/cognite-sdk/badges/version.svg)](https://anaconda.org/conda-forge/cognite-sdk)
  [![mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  This is the Cognite Python SDK for developers and data scientists working with Cognite Data Fusion (CDF).
  The package is tightly integrated with pandas, and helps you work easily and efficiently with data in Cognite Data Fusion (CDF).

  * [SDK Documentation](https://cognite-sdk-python.readthedocs-hosted.com/en/latest/)
  * [CDF API Documentation](https://doc.cognitedata.com/)
  * [Cognite Developer Documentation](https://docs.cognite.com/dev/)


  To install the core version of this package:
  ```bash
  $ pip install cognite-sdk
  ```

  A number of optional dependencies may be specified in order to support a wider set of features.
  The available extras (along with the libraries they include) are:
  - numpy `[numpy]`
  - pandas `[pandas]`
  - geo `[geopandas, shapely]`
  - sympy `[sympy]`
  - functions `[pip]`
  - yaml `[PyYAML]`
  - all `[numpy, pandas, geopandas, shapely, sympy, pip, PyYAML]`
  To include optional dependencies, specify them like this with pip:
  ```bash
  $ pip install "cognite-sdk[pandas, geo]"
  ```
  or like this if you are using poetry:
  ```bash
  $ poetry add cognite-sdk -E pandas -E geo
  ```

  If you regularly need to fetch large amounts of datapoints, consider installing with `numpy`
  (or with `pandas`, as it depends on `numpy`) for best performance, then use the `retrieve_arrays` (or `retrieve_dataframe`) endpoint(s). This avoids building large pure Python data structures, and instead reads data directly into memory-efficient `numpy.ndarrays`.

  On Windows, it is recommended to install `geopandas` and its dependencies using `conda` package manager, see [geopandas installation page](https://geopandas.org/en/stable/getting_started/install.html#installation).
  The following commands create a new environment, install `geopandas` and `cognite-sdk`.
  ```bash
  conda create -n geo_env
  conda activate geo_env
  conda install --channel conda-forge geopandas
  pip install cognite-sdk
  ```

  Wondering about upcoming or previous changes to the SDK? Take a look at the [CHANGELOG](https://github.com/cognitedata/cognite-sdk-python/blob/master/CHANGELOG.md).

  To help you upgrade your code(base) quickly and safely to a newer major version of the SDK, check out our migration guide. It is a more focused guide based on the detailed change log. [MIGRATION GUIDE](https://github.com/cognitedata/cognite-sdk-python/blob/master/MIGRATION_GUIDE.md).

  Want to contribute? Check out [CONTRIBUTING](https://github.com/cognitedata/cognite-sdk-python/blob/master/CONTRIBUTING.md).


pkgId: 967b83e92877608cb93e36bf1e9ee9d051e1a18e4c6d30d3bac516931a77a77b
name: python-cognite-toolkit-help
arch: noarch
version: 0.3.23
epoch: 0
release: 1
summary: Development documents and examples for cognite-toolkit
url: https://developer.cognite.com/sdks/toolkit/
rpm_license: Apache-2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cognite-toolkit-0.3.23-1.src.rpm
location_href: Packages/python-cognite-toolkit-help-0.3.23-1.noarch.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/toolkit/release.yaml?style=for-the-badge)](https://github.com/cognitedata/toolkit/actions/workflows/release.yaml)
  [![Github](https://shields.io/badge/github-cognite/toolkit-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/toolkit)
  [![PyPI](https://img.shields.io/pypi/v/cognite-toolkit?style=for-the-badge)](https://pypi.org/project/cognite-toolkit/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-toolkit?style=for-the-badge)](https://pypistats.org/packages/cognite-toolkit)
  [![GitHub](https://img.shields.io/github/license/cognitedata/toolkit?style=for-the-badge)](https://github.com/cognitedata/toolkit/blob/master/LICENSE)
  [![Docker Pulls](https://img.shields.io/docker/pulls/cognite/toolkit?style=for-the-badge)](https://hub.docker.com/r/cognite/toolkit)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)

  The CDF Toolkit is a command-line interface (`cdf`) used for configuring and administrating
  Cognite Data Fusion (CDF) projects. It ships with modularised `templates` that helps you
  configure Cognite Data Fusion according to best practices.

  It supports three different modes of operation:

  1. As an **interactive command-line tool** used alongside the Cognite Data Fusion web application to retrieve and
     push configuration of the different Cognite Data Fusion services like data sets, data models, transformations,
     and more. This mode also supports configuration of new Cognite Data Fusion projects to quickly get started.
  2. As tool to support the **project life-cyle by scripting and automating** configuration and management of Cognite Data
     Fusion projects where CDF configurations are kept as yaml-files that can be checked into version
     control. This mode also supports DevOps workflows with development, staging, and production projects.
  3. As a **tool to deploy official Cognite project templates** to your Cognite Data Fusion project. The tool comes
     bundled with templates useful for getting started with Cognite Data Fusion, as well as for specific use cases
     delivered by Cognite or its partners. You can also create your own templates and share them.



  Install the Toolkit by running:

  ```bash
  pip install cognite-toolkit
  ```

  Then run `cdf --help` to get started with the interactive command-line tool.



  More details about the tool can be found at
  [docs.cognite.com](https://docs.cognite.com/cdf/deploy/cdf_toolkit/).

  You can find an overview of the modules and packages in the
  [module and package documentation](https://docs.cognite.com/cdf/deploy/cdf_toolkit/references/resource_library).

  See [./CONTRIBUTING.md](./CONTRIBUTING.md) for information about how to contribute to the `cdf-tk` tool or
  templates.


pkgId: ad6fca452db9b708675f188d40184ab5c5c24220d2fa4cc2a5d849ddd87ecc0d
name: python-coguard-cli-help
arch: noarch
version: 0.2.47
epoch: 0
release: 1
summary: Development documents and examples for coguard-cli
url: https://github.com/coguardio/coguard-cli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coguard-cli-0.2.47-1.src.rpm
location_href: Packages/python-coguard-cli-help-0.2.47-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/coguardio/coguard-cli/raw/master/logo.png" alt="Light mode logo" width="500">



  CoGuard is a comprehensive static analysis tool for IT infrastructure
  configurations (cloud and on-premise).

  Finding and
  fixing misconfigurations and security vulnerabilities for IaC, devices,
  containers, cloud settings, and applications. Reduce the noise of CVE
  notifications and focus on small improvements for big wins.



  - [Why CoGuard](#why-coguard)
  - [Introduction to the CLI](#introduction)
  - [Installation](#installation-instructions)
      - [Pre-Requisites](#pre-requisites)
      - [Install from repository or PIP](#installation)
      - [Installation Tips](#installation-remarks)
  - [Usage](#how-to-use-it)
      - [Scan local Docker images](#docker-scan)
      - [Scan local project repositories](#repo-scan)
      - [Extract &amp; scan cloud configurations](#cloud-scan)
      - [General Scan](#general-scan)
      - [Add to CI/CD Pipeline](#add-to-cicd-pipeline)
  - [Screenshots](#screenshots)
  - [Supported Technologies &amp; Roadmap](#supported-technologies)
  - [Learn More](#learn-more)



  Infrastructure as Code (IaC) is here to stay. The versioning and
  continuous scanning of every layer of your IT (on premise and cloud)
  infrastructure is crucial.

  CoGuard's team observed that there are a lot of policy checks on the layers
  communicating to the cloud, but the configurations inside specific
  compute devices such as physical servers, virtual machines or
  containers are mostly neglected, or have silo-ed solutions at best.

  In order to have static analysis practices for IaC that go as deep as
  the available tools for code, every layer needs to be equally addressed.

  In our practice, we observed that, at times, even an awareness of
  locations of configuration files is lacking. This is why we created a
  command line tool helping with discovering those configurations, and
  scanning them.

  CoGuard's CLI combines multiple ways to extract and scan your configuration
  files.

  1. Docker images: Modern
     container scanners check for versions of software and libraries
     installed on those containers, and establish if there are common known
     vulnerabilities and exposures (CVEs). The
     CoGuard CLI is trying to find known configuration files for e.g. web
     servers or databases, and scans these for security and best practice.
     Additionally, the last Docker file used to create an image is analyzed
     as well.
  2. Project Repositories: Modern projects store their infrastructure
     information inside code repositories for better visibility and
     traceability. CoGuard can extract Infrastructure as Code (IaC)
     files and other supported configurations. It also searches for
     external container references and scans these as well.
  3. Cloud configurations not represented as IaC: Many organizations
     have either not yet started using IaC tools, or have a hybrid model
     of part IaC, part manual management. For these cases, we can
     extract cloud configurations for AWS, Azure or GCP, and scan them
     as well.



  This project is the command line interface to CoGuard, with additional
  functionality for the auto-discovery of configuration files.

  The current release scans for:
  1. Docker images and its contents,
  2. project folders (such as GitHub Repositories) and
  3. will automatically extracted cloud configurations from the AWS, Azure and GCP

  It searches for known [configuration files](#supported-technologies) of different
  software packages (like webservers, databases, etc.), and scans these
  configurations for configuration errors and security best practices.





  You need to have `python3`, `pip3` and `docker` installed on your system.
  Instructions for different operating systems and commands to be used for Python and Pip are provided below.

  <details>
  <summary>Ubuntu/Debian</summary>

  ```shell
  sudo apt install -y python3 python3-pip
  ```
  </details>

  <details>
  <summary>Alpine</summary>

  ```shell
  apk add python3 py3-pip
  ```
  </details>

  <details>
  <summary>CentOS/Fedora</summary>

  ```shell
  sudo yum install -y python3 python3-pip
  ```
  </details>

  <details>
  <summary>Arch Linux</summary>

  ```shell
  sudo pacman -S python python-pip
  ```
  </details>

  <details>
  <summary>Mac OS</summary>
  Assuming you are using [Homebrew](https://brew.sh), you have to run

  ```shell
  brew install python3
  ```
  </details>

  <details>
  <summary>Windows</summary>

  Download Python3 for Windows using [this link](https://www.python.org/downloads/windows/), and
  install it.

  </details>



  CoGuard CLI can either be pulled from this repository and used
  directly, or installed via `pip`:

  ```shell
  pip3 install coguard-cli
  ```

  This is a reminder that it is a requirement to have [Docker](https://docker.com) installed locally.




  **Remark 1**: It may happen that the folder where `pip` is installing packages is not
  in included in `PATH`. We have observed it on some Ubuntu installations, and on
  Homebrew Mac installs. For the Linux case, such as Ubuntu,
  you can find the binary usually under `$HOME/.local/bin/coguard`, i.e. you run
  ```shell
  $HOME/.local/bin/coguard docker-image [<YOUR-IMAGE-NAME-OR-ID>]
  ```
  For the Mac case, it is often installed under `~/Library/Python/<YOUR_PYTHON_VERSION>/bin/coguard`, i.e. you would run
  ```shell
  ~/Library/Python/<YOUR_PYTHON_VERSION>/bin/coguard docker-image [<YOUR-IMAGE-NAME-OR-ID>]
  ```

  If you omit the image ID parameter, CoGuard will scan all the images currently
  stored on your device.

  **Remark 2**: Windows users need to be allowed to create and read symbolic links.
  This can be achieved using three options:
  <details>
  <summary>Option 1</summary>
  1. Run the CoGuard execution as admin temporarily. This can be achieved by opening the
     PowerShell or command prompt as administrative user (right click on the icon),
     or by issuing the command
     ```shell
     Start-Process powershell -Verb runAs
     ```
     inside an already open command/Powershell window.
  </details>
  <details>
  <summary>Option 2</summary>
  2. Run Windows in Developer Mode (instructions on how to run Windows as a developer can
     be found [here](https://docs.microsoft.com/en-us/gaming/game-bar/guide/developer-mode)).
  </details>
  <details>
  <summary>Option 3</summary>
  3. Run CoGuard on a Linux virtual machine, e.g. using the Windows subsystem for Linux.
     This is commonly installed with Docker Desktop for Windows. If you do not have it installed,
     then installation instructions can be found
     [here](https://docs.microsoft.com/en-us/windows/wsl/install).
     The installation steps for CoGuard using WSL are equivalent to the pre-requisites
     and installation steps described for Linux (dependent on the distribution you choose).
  </details>




  Any of the following options requires you to create a CoGuard account.
  After completion, this image check will return the findings of CoGuard
  on this particular image. You can view the latest historical scan results
  when logging in to [https://portal.coguard.io](https://portal.coguard.io).



  Using the CoGuard CLI, you can run a scan on your local Docker images
  using

  ```shell
  coguard docker-image [scan] [<YOUR-IMAGE-NAME-OR-ID>]
  ```



  Using the CoGuard CLI, you can run a scan on your local
  file repositories using

  ```shell
  coguard folder [scan] [<PATH-TO-FOLDER>]
  ```



  Using the CoGuard CLI, you can run a scan a current snapshot of your
  cloud configurations. This requires you to have the respective
  cloud CLI tools (`aws-cli` for AWS, `gcloud` for GCP or `az` for
  Azure) installed and authenticated on your device.

  ```shell
  coguard cloud [scan] {aws, azure, gcp}
  ```

  The extraction may take a couple of minutes, depending on your
  internet speed.



  To get a general scan, which includes all locally installed Docker
  images, anything in the current-working directory (recursive) and any
  installed cloud provider authentication, simply run

  ```shell
  coguard scan
  ```



  CoGuard can be included as a step in your CI/CD pipeline. CoGuard generates the
  necessary templates and scripts.

  GitHub Actions is available in the current release. To generate e.g. a GitHub Actions
  YAML which automatically scans your repository on
  pull request/push, simply type

  ```shell
  coguard pipeline github add <PATH_TO_YOUR_REPOSITORY>
  ```
  [Future support is planned](#support-roadmap) for GitLab CI/CD, Jenkins, Bamboo, CircleCI, etc.



  Here is a screenshot of a sample scan:

  ![](./screenshot.png)

  As you can see, CoGuard also analyzes the last Dockerfile used.

  The checks are gathered from different security controls, but also
  directly from the user manuals of these software projects. At times, known issues for
  certain versions and security remediations specific to a certain version are being taken
  into account as well.




  CoGuard currently supports the the auto-discovery of configuration files inside
  Docker containers, folders and cloud configuration exports. The full list of configurations files
  can be found
  [in this folder](https://github.com/coguardio/coguard-cli/tree/master/src/coguard_cli/discovery/config_file_finders).

  - Supported Applications &amp; Infrastructure as Code
      - Apache Kafka
      - Apache Tomcat
      - Apache WebServer
      - CloudFormation
      - Dockerfile
      - ElasticSearch
      - Helm
      - Kerberos
      - Kubernetes
      - MongoDB
      - MySQL
      - Netlify
      - NGINX
      - OpenTelemetry Collector
      - PostgreSQL
      - Redis
      - TerraForm
  - Supported Cloud Hosts
      - AWS
      - Azure
      - GCP
      - OVH Cloud
  - <a id="supported-roadmap"></a>Roadmap (Future Support Planned)
      - Ansible
      - Jenkins
      - Bamboo
      - CircleCI
      - OpenAPI
      - Puppet
      - BitBucket Pipelines
      - [Contact us](https://coguard.io/contact) for full list or to add a specific request or custom rules

  This list
  will expand in the future. In addition, we are scanning the
  Dockerfile used to create the images, and will add some Linux
  configuration files in the near future.



  - [CoGuard](https://www.coguard.io)
  - [Blog](https://www.coguard.io/blog)
  - [Contact Us](https://coguard.io/contact)


pkgId: 32d8cad8236f4017f9157eb30240d2c62bf29473822cff03afc54455869865be
name: python-coiled-help
arch: noarch
version: 1.69.0
epoch: 0
release: 1
summary: Development documents and examples for coiled
url: https://coiled.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coiled-1.69.0-1.src.rpm
location_href: Packages/python-coiled-help-1.69.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="https://raw.githubusercontent.com/coiled/logos/master/Coiled-Logo_Horizontal_Black-RGB.png" width="200" style="max-width: 200px;" alt="Coiled">
  </p>

  <p align="center">
    <a href="https://coiled.io">Coiled.io</a> •
    <a href="https://docs.coiled.io/user_guide/index.html">Documentation</a> •
    <a href="https://join.slack.com/t/coiled-users/shared_invite/zt-hx1fnr7k-In~Q8ui3XkQfvQon0yN5WQ">Community</a> •
    <a href="https://docs.coiled.io/user_guide/support.html">Support</a>
  </p>

  Coiled is a deployment-as-a-service library for scaling Python with Dask, a popular open source library for parallel analytics. Coiled manages cloud resources, networking, software environments, and everything you need to scale Python in the cloud robustly and easily.

  Go to https://cloud.coiled.io to get started with Coiled.


pkgId: 1029487b92aa0b5736e78814b7aa93527eef217d0e401520aef25aef620652ca
name: python-coinmetrics-api-client-help
arch: noarch
version: 2024.12.16.21
epoch: 0
release: 1
summary: Development documents and examples for coinmetrics-api-client
url: https://coinmetrics.github.io/api-client-python/site/index.html
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coinmetrics-api-client-2024.12.16.21-1.src.rpm
location_href: Packages/python-coinmetrics-api-client-help-2024.12.16.21-1.noarch.rpm
checksum_type: sha256
description:
   0   asset             1 non-null      object
   1   time              1 non-null      datetime64[ns]
   2   ReferenceRateUSD  1 non-null      float64
  dtypes: datetime64[ns](1), float64(1), object(1)
  memory usage: 152.0+ bytes
  ```
  Note that in order to pass a custom datetime object, setting a dtype_mapper is mandatory.
  Pandas type conversion tends to be more performant. But if there are custom operations that must be done using numpy datatypes, this option will let you perform them.

  You can also easily export timeseries data to csv and json files with builtin functions on the `DataCollection` type.
  For example this script will export Coinbase btc and eth trades for a date to csv and json files respectively:
  ```python
      start_date = datetime.date(year=2022, month=1, day=1)
      end_date = datetime.datetime(year=2022, month=1, day=1)
      market_trades_btc = client.get_market_trades(page_size=1000, markets="coinbase-btc-usd-spot", start_time=start_date, end_time=end_date)
      market_trades_btc.export_to_csv("jan_1_2022_coinbase_btc_trades.csv")
      market_trades_eth = client.get_market_trades(page_size=1000, markets="coinbase-eth-usd-spot", start_time=start_date, end_time=end_date)
      market_trades_eth.export_to_json("jan_1_2022_coinbase_eth.json")
  ```

  You can make the datapoints to iterate from start (default) or from end.
  for that you should use a paging_from argument like the following:
  ```
  from coinmetrics.api_client import CoinMetricsClient
  from coinmetrics.constants import PagingFrom
  client = CoinMetricsClient()
  for metric_data in client.get_asset_metrics(assets='btc', metrics=['ReferenceRateUSD'],
                                              paging_from=PagingFrom.START):
      print(metric_data)
  ```
  PagingFrom.END: is available but by default it will page from the start.

  There are two additional options for the API Client - `debug_mode` and `verbose`. These two options log network calls
  to the console, and in the case of `debug_mode` it will generate a log file of all the network requests and the time
  it takes to call them. These tools can be used to diagnose issues in your code and also to get a better understanding
  of request times so that users can write more performant code. For example, running the below code:
  ```python
  import os
  from coinmetrics.api_client import CoinMetricsClient
  api_key = os.environ['CM_API_KEY']
  if __name__ == '__main__':
      client = CoinMetricsClient(api_key=api_key, debug_mode=True)
      reference_rates_example = client.get_asset_metrics(assets=['btc', 'algo', 'eth'], metrics=['ReferenceRateUSD'])
      for data in reference_rates_example:
          continue
  ```
  The console output will look like:
  ```commandline
  [DEBUG] 2023-01-09 11:01:02,044 - Starting API Client debugging session. logging to stdout and cm_api_client_debug_2023_01_09_11_01_02.txt
  [DEBUG] 2023-01-09 11:01:02,044 - Using coinmetrics version 2022.11.14.16
  [DEBUG] 2023-01-09 11:01:02,044 - Current state of API Client, excluding API KEY: {'_verify_ssl_certs': True, '_api_base_url': 'https://api.coinmetrics.io/v4', '_ws_api_base_url': 'wss://api.coinmetrics.io/v4', '_http_header': {'Api-Client-Version': '2022.11.14.16'}, '_proxies': {'http': None, 'https': None}, 'debug_mode': True, 'verbose': False}
  [DEBUG] 2023-01-09 11:01:02,044 - Attempting to call url: timeseries/asset-metrics with params: {'assets': ['btc', 'algo', 'eth'], 'metrics': ['ReferenceRateUSD'], 'frequency': None, 'page_size': None, 'paging_from': 'start', 'start_time': None, 'end_time': None, 'start_height': None, 'end_height': None, 'start_inclusive': None, 'end_inclusive': None, 'timezone': None, 'sort': None, 'limit_per_asset': None}
  [DEBUG] 2023-01-09 11:01:02,387 - Response status code: 200 for url: https://api.coinmetrics.io/v4/timeseries/asset-metrics?api_key=[REDACTED]&assets=btc%2Calgo%2Ceth&metrics=ReferenceRateUSD&paging_from=start took: 0:00:00.342874 response body size (bytes): 9832
  [DEBUG] 2023-01-09 11:01:02,388 - Attempting to call url: timeseries/asset-metrics with params: {'assets': ['btc', 'algo', 'eth'], 'metrics': ['ReferenceRateUSD'], 'frequency': None, 'page_size': None, 'paging_from': 'start', 'start_time': None, 'end_time': None, 'start_height': None, 'end_height': None, 'start_inclusive': None, 'end_inclusive': None, 'timezone': None, 'sort': None, 'limit_per_asset': None, 'next_page_token': '0.MjAxOS0wOS0zMFQwMDowMDowMFo'}
  [DEBUG] 2023-01-09 11:01:02,559 - Response status code: 200 for url: https://api.coinmetrics.io/v4/timeseries/asset-metrics?api_key=[REDACTED]&assets=btc%2Calgo%2Ceth&metrics=ReferenceRateUSD&paging_from=start&next_page_token=0.MjAxOS0wOS0zMFQwMDowMDowMFo took: 0:00:00.171487 response body size (bytes): 9857
  ```
  Then it can be easier to understand what network calls the API Client is making, and where any issues may exist. If you
  wish to dig even deeper, you may consider modifying the `_send_request()` method of the API Client to log additional
  data about the state of your environment, or anything else that would help diagnose issues. You will notice a log file
  generated in the format `cm_api_client_debug_2023_01_09_11_01_02.txt`. This log file might be helpful for your own use
  or to give more context if you are working with Coin Metrics customer success.

  Sometimes your organization network have special rules on SSL certs verification and in this case you might face the
  following error when running the script:
  ```text
  SSLError: HTTPSConnectionPool(host='api.coinmetrics.io', port=443): Max retries exceeded with url: <some_url_path> (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self signed certificate in certificate chain (_ssl.c:1123)')))
  ```
  In this case, you can pass an option during client initialization to disable ssl verification for requests like this:
  ```python
  client = CoinMetricsClient(verify_ssl_certs=False)
  ```
  We don't recommend setting it to False by default and you should make sure you understand the security risks of disabling SSL certs verification.
  Additionally, you may choose to specify the path to the SSL certificates on your machine. This may cause errors where
  Python is unable to locate the certificates on your machine, particularly when using Python virtual environments.
  ```python
  from coinmetrics.api_client import CoinMetricsClient
  SSL_CERT_LOCATION = '/Users/<USER_NAME>/Library/Python/3.8/lib/python/site-packages/certifi/cacert.pem'
  client = CoinMetricsClient(verify_ssl_certs=SSL_CERT_LOCATION)
  ```
  A quick way to find the certs on your machine is:
  `python3 -c "import requests; print(requests.certs.where())"`
  And note that this will change based on whether or not you are using a [Python virtual environment or not](https://realpython.com/python-virtual-environments-a-primer/)

  Related to SSL Certs verification, you may have trouble installing and updating PyPi packages to your local environment.
  So you may need to choose the best solution for your company and environment - either using package managers or
  installing offline.

  Full instructions for setting up your environment to use conda, pip, yarn, npm, etc. can be [found here](https://medium.com/@iffi33/dealing-with-ssl-authentication-on-a-secure-corporate-network-pip-conda-git-npm-yarn-bower-73e5b93fd4b2).
  Additionally, a workaround to disable SSL verification when installing a trusted Python package is this:
  ```commandline
  pip install --trusted-host pypi.python.org <packagename>
  ```
  Although it is important to make sure you understand the risks associated with disabling SSL verification and ensure
  compliance with company policies.

  It may be easier to download and install the package locally. Steps:
  1. Download the files for the [Coin Metrics API Client from PyPi](https://pypi.org/project/coinmetrics-api-client/#files)
  2. [Install it locally](https://packaging.python.org/en/latest/tutorials/installing-packages/#installing-from-local-archives)

  Sometimes your organization has special rules on making requests to third parties and you have to use proxies in order to comply with the rules.
  For proxies that don't require auth you can specify them similar to this example:
  ```python
  client = CoinMetricsClient(proxy_url=f'http://<hostname>:<port>')
  ```
  For proxies that require auth, you should be able to specify username and password similar to this example:
  ```python
  client = CoinMetricsClient(proxy_url=f'http://<username>:<password>@<hostname>:<port>')
  ```

  For more information about the available methods in the client please reference [API Client Spec](https://coinmetrics.github.io/api-client-python/site/api_client.html)


pkgId: afaf21f4da47f4b5028b6017f65a9bbf052993be799e5b2d3b185b16ceb7f23d
name: python-colcon-defaults-help
arch: noarch
version: 0.2.9
epoch: 0
release: 1
summary: Development documents and examples for colcon-defaults
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-colcon-defaults-0.2.9-1.src.rpm
location_href: Packages/python-colcon-defaults-help-0.2.9-1.noarch.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide custom default values for the command line arguments from a configuration file.
  For more information about the format of the configuration file see `colcon.readthedocs.io <http://colcon.readthedocs.io/en/released/user/configuration.html#defaults-yaml>`_.


pkgId: d876aee677ae5f7d18e9d6715ca9038df0ed501b1c4ab5cabd37f3769d7286cc
name: python-collaborative-article-sharing-help
arch: noarch
version: 0.1.0b13
epoch: 0
release: 1
summary: Development documents and examples for collaborative-article-sharing
url: https://github.com/upayanmazumder/collaborative-Article-Sharing
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-collaborative-article-sharing-0.1.0b13-1.src.rpm
location_href: Packages/python-collaborative-article-sharing-help-0.1.0b13-1.noarch.rpm
checksum_type: sha256
description:
  A Command-Line Interface (CLI) tool for interacting with the [Collaborative-Article-Sharing](https://github.com/upayanmazumder/Collaborative-Article-Sharing) project.



  > For a full comprehensive list, use the help command

  - **`cas info`**
    Displays project and developer information.

  - **`cas help`**
    Shows the help article for available commands.

  - **`cas auth`**
    Initiates the authentication process.

  - **`cas push <article-link> [-m <message>]`**
    Adds an article with an optional message.

  - **`cas pull`**
    Retrieves your saved articles.

  - **`cas group:create`**
    Create a group

  - **`cas group:delete`**
    Delete a group

  - **`cas group:privacy`**
    Change a group's privacy settings

  - **`cas group:list`**
    Get the list of public groups



  To run the CLI tool, first navigate to the CLI folder using the command:

  ```sh
  cd /d:/upayanmazumder/Collaborative-Article-Sharing/CLI
  ```

  Then, execute the following command to start the CLI:

  ```sh
  pip install -e .
  ```

  Once build completes, use the `cas` command


pkgId: e20564f91e0ee66d8b7c3cc039b45a2f9454bf60e610e35130ce479df10e0d89
name: python-collective.dms.mailcontent-help
arch: noarch
version: 1.16.3
epoch: 0
release: 1
summary: Development documents and examples for collective.dms.mailcontent
url: https://github.com/collective/collective.dms.mailcontent
rpm_license: gpl
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-collective.dms.mailcontent-1.16.3-1.src.rpm
location_href: Packages/python-collective.dms.mailcontent-help-1.16.3-1.noarch.rpm
checksum_type: sha256
description:
  Base mail content class (paper document, email) for document management system.
  This product is an extension for `collective.dms.basecontent <https://pypi.org/project/collective.dms.basecontent>`_
  .


pkgId: 48bb92dc768948e32ca717908f8c319b819f2bd75bc9bea5250c9dcfc89e606c
name: python-collective.pdbpp-help
arch: noarch
version: 1.0.0a4
epoch: 0
release: 1
summary: Development documents and examples for collective.pdbpp
url: https://github.com/collective/collective.pdbpp
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-collective.pdbpp-1.0.0a4-1.src.rpm
location_href: Packages/python-collective.pdbpp-help-1.0.0a4-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://github.com/collective/collective.pdbpp/actions/workflows/plone-package.yml/badge.svg)](https://github.com/collective/collective.pdbpp/actions/workflows/plone-package.yml)
  [![Coveralls](https://coveralls.io/repos/github/collective/collective.pdbpp/badge.svg?branch=main)](https://coveralls.io/github/collective/collective.pdbpp?branch=main)
  [![image](https://codecov.io/gh/collective/collective.pdbpp/branch/master/graph/badge.svg)](https://codecov.io/gh/collective/collective.pdbpp)
  [![Latest Version](https://img.shields.io/pypi/v/collective.pdbpp.svg)](https://pypi.python.org/pypi/collective.pdbpp/)
  [![Egg Status](https://img.shields.io/pypi/status/collective.pdbpp.svg)](https://pypi.python.org/pypi/collective.pdbpp)
  ![image](https://img.shields.io/pypi/pyversions/collective.pdbpp.svg?style=plastic%20%20%20:alt:%20Supported%20-%20Python%20Versions)
  [![License](https://img.shields.io/pypi/l/collective.pdbpp.svg)](https://pypi.python.org/pypi/collective.pdbpp/)



  An addon for Plone that does allow you to use the [pdbpp](https://github.com/pdbpp/pdbpp) package



  Install `collective.pdbpp` by adding it to your buildout, e.g.:

      [instance]
      eggs +=
          collective.pdbpp

  and then running `bin/buildout`.

  When your instance starts you can enter a pdb session by adding the path `pdb` to any URL, e.g.:

  - http://localhost:8080/pdb
  - http://localhost:8080/Plone/pdb




  The [Syslab.com](https://www.syslab.com) Team.



  Put your name here, you deserve it!

  - Alessandro Pisa, [Syslab.com](https://www.syslab.com)



  - Issue Tracker:
    <https://github.com/collective/collective.pdbpp/issues>
  - Source Code: <https://github.com/collective/collective.pdbpp>
  - Documentation: <https://docs.plone.org/foo/bar>



  If you are having issues, please let us know in the [issue tracker](https://github.com/collective/collective.pdbpp/issues).



  The project is licensed under the GPLv2.





  - ale-rt, alessandro.pisa@gmail.com








  - Nothing changed yet.




  - Add features from rich to make debugging easier.




  - Initial release.
    [ale-rt]


pkgId: 824f6e24c8ae1460ab5fd00f6ed2ea5ee4d65d84d49b2abebebef4a1a763b9af
name: python-collective.solr-help
arch: noarch
version: 9.4.0
epoch: 0
release: 1
summary: Development documents and examples for collective.solr
url: https://github.com/collective/collective.solr
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-collective.solr-9.4.0-1.src.rpm
location_href: Packages/python-collective.solr-help-9.4.0-1.noarch.rpm
checksum_type: sha256
description:
  ``collective.solr`` integrates the `Solr`_ search engine with `Plone`_.
  Apache Solr is based on Lucene and is *the* enterprise open source search engine.
  It powers the search of sites like Twitter,
  the Apple and iTunes Stores, Wikipedia, Netflix and many more.
  Solr does not only scale to any level of content,
  but provides rich search functionality,
  like faceting, geospatial search, suggestions, spelling corrections, indexing of binary formats and a whole variety of powerful tools to configure custom search solutions.
  It has integrated clustering and load-balancing to provide a high level of robustness.
  ``collective.solr`` comes with a default configuration and setup of Solr that makes it extremely easy to get started,
  yet provides a vastly superior search quality compared to Plone's integrated text search based on ``ZCTextIndex``.


pkgId: 16fa33172016d9b5cfde194523c66fc917ef2caf8090d6e0ee6560956f0c8e6e
name: python-colomoto-jupyter-help
arch: noarch
version: 0.8.11
epoch: 0
release: 1
summary: Development documents and examples for colomoto-jupyter
url: https://github.com/colomoto/colomoto-jupyter
rpm_license: LGPL v3+/CeCILL-C
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-colomoto-jupyter-0.8.11-1.src.rpm
location_href: Packages/python-colomoto-jupyter-help-0.8.11-1.noarch.rpm
checksum_type: sha256
description:
  Provides helper functions for integration in the CoLoMoTo Jupyter notebook.

  See https://github.com/colomoto/colomoto-jupyter


pkgId: efbef35a44d2094d7ae41fab2cad2c1b2b325c55b82ac5ca4c4aa2a4617fa2b3
name: python-colossalai-nightly-help
arch: noarch
version: 2024.12.14
epoch: 0
release: 1
summary: Development documents and examples for colossalai-nightly
url: https://www.colossalai.org
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-colossalai-nightly-2024.12.14-1.src.rpm
location_href: Packages/python-colossalai-nightly-help-2024.12.14-1.noarch.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: 18bb39246c2c687c11e375dc1b7767210b4ad8738416f3bbdca43cbb134779fa
name: python-colourmap-help
arch: noarch
version: 1.1.18
epoch: 0
release: 1
summary: Development documents and examples for colourmap
url: https://erdogant.github.io/colourmap
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-colourmap-1.1.18-1.src.rpm
location_href: Packages/python-colourmap-help-1.1.18-1.noarch.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: 135ee30f75164057da92dee194b1464c428bb03e9b91f505cc089ee31d0ce8e9
name: python-colpali-engine-help
arch: noarch
version: 0.3.5
epoch: 0
release: 1
summary: Development documents and examples for colpali-engine
url: https://pypi.org/project/colpali-engine/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-colpali-engine-0.3.5-1.src.rpm
location_href: Packages/python-colpali-engine-help-0.3.5-1.noarch.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 and an effective batch size of 32. | ✅                   |
  | [vidore/colqwen2-v1.0](https://huggingface.co/vidore/colqwen2-v1.0) | 89.3                                                         | Apache 2.0 | • Similar to `vidore/colqwen2-v0.1`, but trained with more powerful GPUs and with a larger effective batch size (256). | ✅                   |

  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.                                                                                        |
  | EmbedAnything | [`EmbedAnything`](https://github.com/StarlightSearch/EmbedAnything) Allows end-to-end ColPali inference with both Candle and ONNX backend.                                                                                                           |
  | 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.                                                                           |
  | ColiVara      | [`ColiVara`](https://github.com/tjmlabs/ColiVara/) is retrieval API that allows you to store, search, and retrieve documents based on their visual embedding. It is a web-first implementation of the ColPali paper using ColQwen2 as the LLM model. |
  | BentoML       | Deploy ColPali easily with BentoML using [this example repository](https://github.com/bentoml/BentoColPali). BentoML features adaptive batching and zero-copy I/O to minimize overhead.                                                              |

  | 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)                             |
  | Multimodal Retrieval-Augmented Generation (RAG) with Document Retrieval (ColPali) and Vision Language Models (VLMs) | [Sergio Paniego](https://huggingface.co/learn/cookbook/multimodal_rag_using_document_retrieval_and_vlms)                                        |
  | Document Similarity Search with ColPali                                                                             | [Frank Sommers](https://colab.research.google.com/github/fsommers/documentai/blob/main/Document_Similarity_with_ColPali_0_2_2_version.ipynb)    |
  | End-to-end ColPali inference with EmbedAnything                                                                     | [Akshay Ballal (EmbedAnything)](https://colab.research.google.com/drive/1-Eiaw8wMm8I1n69N1uKOHkmpw3yV22w8?usp=sharing)                          |
  | ColiVara: A ColPali Retrieval API                                                                                   | [A simple RAG Example](https://github.com/tjmlabs/ColiVara-docs/blob/main/cookbook/RAG.ipynb)                                                   |

  - 📝 = 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: 4f2c288336d56a70bb44e1018ef2670c99b9eab86b41027d36cd108d387cbcb7
name: python-cometx-help
arch: noarch
version: 2.2.22
epoch: 0
release: 1
summary: Development documents and examples for cometx
url: https://github.com/comet-ml/comet-sdk-extensions/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cometx-2.2.22-1.src.rpm
location_href: Packages/python-cometx-help-2.2.22-1.noarch.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: 88958d0ec3532b2fa7ca6a9ffc7a65dcf4b6763dfac6137afad8ec84f4df6532
name: python-comfy-proxy-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for comfy-proxy
url: https://pypi.org/project/comfy-proxy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-comfy-proxy-0.1.0-1.src.rpm
location_href: Packages/python-comfy-proxy-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python client library for interacting with ComfyUI servers and managing image generation workflows.



  - Single and multi-instance ComfyUI server management
  - Async workflow execution
  - Flexible address configuration (single, multiple, port ranges)
  - Built-in workflow templates
  - Customizable image sizes and parameters
  - Websocket-based image generation and retrieval



  ComfyProxy requires Python 3.11 or later. Install using pip:

  ```bash
  pip install comfy-proxy
  ```



  ```python
  import asyncio
  from comfy_proxy.comfy import SingleComfy
  from comfy_proxy.workflows.flux import FluxModel, FluxWorkflowParams, FluxWorkflow
  from comfy_proxy.workflow import Sizes

  async def generate_image():
      
      comfy = Comfy("127.0.0.1:7821")

      
      model = FluxModel()
      params = FluxWorkflowParams(
          prompt="a beautiful sunset over mountains",
          model=model,
          size=Sizes.LANDSCAPE_16_9,
          seed=42,
          batch_size=1
      )

      
      workflow = FluxWorkflow(params)
      async for image_data in comfy.generate(workflow):
          with open("generated_image.png", "wb") as f:
              f.write(image_data)
          break  # Save first image only


  asyncio.run(generate_image())
  ```



  ComfyProxy can distribute work across multiple ComfyUI servers:

  ```python
  from comfy_proxy.comfy import Comfy


  comfy = Comfy("127.0.0.1:8188-8192")  # Port range

  comfy = Comfy(["127.0.0.1:8188", "127.0.0.1:8189"])  # List

  comfy = Comfy("127.0.0.1:8188,127.0.0.1:8189")  # Comma-separated
  ```



  Requirements:
  - Python 3.11+
  - Poetry for dependency management

  Setup:
  ```bash

  git clone https://github.com/yourusername/comfy-proxy.git
  cd comfy-proxy


  poetry install


  poetry run pytest
  ```



  ComfyProxy comes with some built-in workflows (like `FluxWorkflow`), but you can easily create your own:

  ```python
  from comfy_proxy.workflow import ComfyWorkflow, ComfyNode

  class MyCustomWorkflow(ComfyWorkflow):
      def __init__(self, params):
          super().__init__()
          self.params = params
          self._build_workflow()

      def _build_workflow(self):
          
          checkpoint_node = self.add_node(
              "CheckpointLoaderSimple",
              {"ckpt_name": "sd_xl_base_1.0.safetensors"}
          )
          
  ```

  We welcome contributions of basic workflows for popular models:
  - Stable Diffusion 1.5
  - SDXL
  - SD Turbo
  - SD 3.0
  - etc.

  For more complex use cases, you can implement the `ComfyWorkflow` class directly in your own codebase to create custom workflows with additional functionality.



  MIT License - see [LICENSE](LICENSE) file for details.


pkgId: 178e9c3fd1fa47210793a63b39407c7c6ac46d4cb6a5a0c5240b4a83f7d4acbb
name: python-commit-crafter-ai-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for commit-crafter-ai
url: https://github.com/SerhatUzbas/commit-crafter-ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-commit-crafter-ai-1.0.2-1.src.rpm
location_href: Packages/python-commit-crafter-ai-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Ai tool to craft commit from terminal.



  ```bash
  pip install commit-crafter-ai
  ```



  ```bash
  commit-crafter-ai craft
  ```



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



  - Generates clear and concise commit messages
  - Follows conventional commit format
  - Provides detailed descriptions of changes
  - Easy to use command-line interface



  - Python 3.7+
  - OpenAI API key



  ```bash
  python -m twine upload dist/*
  ```



  1. Export your OpenAI API key:

  ```bash

  export OPENAI_API_KEY="your-api-key-here"


  set OPENAI_API_KEY=your-api-key-here


  $env:OPENAI_API_KEY="your-api-key-here"
  ```

  2. The API key can also be added to your shell configuration file (~/.bashrc, ~/.zshrc, etc.) for persistence:

  ```bash
  echo 'export OPENAI_API_KEY="your-api-key-here"' >> ~/.bashrc  # or ~/.zshrc
  ```


pkgId: b0fefecc599045fa566fe08b6a9398f1f57061106b1ac4bc1efe887e29f0f793
name: python-common-hooks-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for common-hooks
url: https://github.com/Fadope1/common-hooks
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-common-hooks-0.0.1-1.src.rpm
location_href: Packages/python-common-hooks-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This package is made to provide a simple way to create hooks (callback) to common packages and functions.
  Generally speaking, its relatively simple to create a hook, you import and attach to the process.


  [x] Create basic tests
  [ ] Upload to pypi
  [ ] Advanced test support
  [ ] Integrate requests library
  [ ] Integrate aiohttp library



  There are multiple possible installations, depending on your need.

  1. Simple install only the core hooks that do no require any dependencies (which is currently none!):

      ```bash
      pip install common_hooks
      ```

  1. Installing all (Not recommended):

      ```bash
      pip install common_hooks[all]
      ```

  1. Installing only the hooks that require a specific package:

      ```bash
      pip install common_hooks[package_name]
      ```

  1. You can install multiple hooks using comma separated list, for example:

      ```bash
      pip install common_hooks[httpx,fastapi]
      ```



  - httpx
  - fastapi



  1. You need to define a callback function that is structured like fastapi lifespans:

  ```python
  def my_callback(input):
      print(f"BEFORE: {inputs=}")
      result = yield
      print(f"AFTER: {result=}")
  ```

  To attach the callback function to all httpx GET calls:

  ```python
  from common_hooks.httpx import hook
  from common_hooks.conditions import HttpRequestCondition # optional condition

  complex_condition = HttpRequestCondition(methods=["GET"])
  hook.attach(my_callback, condition=complex_condition)
  ```

  To attach a callback function to all httpx POST calls:

  ```python
  from common_hooks.httpx import hook
  from common_hooks.conditions import HttpRequestCondition

  complex_condition = HttpRequestCondition(methods=["POST"]) # optional
  hook.attach(my_callback, condition=complex_condition)
  ```

  After attaching, you must install the hook to apply the callback(s):

  ```python
  hook.install()
  ```

  To use multiple hooks in the same script rename them using "as", common conditions can be reused:

  ```python
  from common_hooks.conditions import HttpRequestCondition
  from common_hooks.httpx import hook as httpx_hook
  from common_hooks.fastapi import hook as fastapi_hook

  complex_condition = HttpRequestCondition(methods=["POST"])

  hook.attach(my_callback, condition=complex_condition)
  httpx_hook.install()

  fastapi_hook.attach(my_callback, condition=complex_condition)
  fastapi_hook.install()
  ```
  This script will apply the callback to all POST requests made by httpx and all POST requests received by fastapi.



  - aiohttp
  - requests



  - flask
  - django
  - sqlalchemy
  - inbuilt functions
  - inbuilt classes



  If you have a hook you would like to add, please create a pull request with the hook and a test to ensure it works as expected.
  A hook must inherit from the CoreHook class you can import using:

  ```python
  from common_hooks import CoreHook
  ```

  Check implementation of other hooks to see how to implement your own.


pkgId: 0c59721b0035b9ee0911fdab966f11bdf9ed22d1046733c934ef6448a165aedf
name: python-communex-help
arch: noarch
version: 0.1.36
epoch: 0
release: 1
summary: Development documents and examples for communex
url: https://pypi.org/project/communex/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-communex-0.1.36-1.src.rpm
location_href: Packages/python-communex-help-0.1.36-1.noarch.rpm
checksum_type: sha256
description:
  [open an issue on GitHub]: https://github.com/agicommies/communex/issues/new/choose
  [CommuneX Discord channel]: https://go.agicommies.org/communex-channel
  [GitHub discussions page]: https://github.com/agicommies/communex/discussions
  [ruff-installation]: https://docs.astral.sh/ruff/installation/


pkgId: e14dab599732a94def3901ccb27dc8fa6bed3fa07a833d1234d62d7c8d680d5a
name: python-compas-help
arch: noarch
version: 2.8.0
epoch: 0
release: 1
summary: Development documents and examples for compas
url: https://compas-dev.github.io/compas
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-compas-2.8.0-1.src.rpm
location_href: Packages/python-compas-help-2.8.0-1.noarch.rpm
checksum_type: sha256
description:
  ![build](https://github.com/compas-dev/compas/workflows/build/badge.svg)
  [![codecov](https://codecov.io/github/compas-dev/compas/graph/badge.svg?token=wpkfew9szQ)](https://codecov.io/github/compas-dev/compas)
  [![GitHub - License](https://img.shields.io/github/license/compas-dev/compas.svg)](https://github.com/compas-dev/compas)
  [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
  [![pip downloads](https://img.shields.io/pypi/dm/compas)](https://pypi.python.org/project/COMPAS)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/COMPAS.svg)](https://pypi.python.org/project/COMPAS)
  [![PyPI - Latest Release](https://img.shields.io/pypi/v/COMPAS.svg)](https://pypi.python.org/project/COMPAS)
  [![Conda (channel only)](https://img.shields.io/conda/vn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
  [![Conda - Platform](https://img.shields.io/conda/pn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
  [![DOI](https://zenodo.org/badge/104857648.svg)](https://zenodo.org/badge/latestdoi/104857648)
  [![Twitter Follow](https://img.shields.io/twitter/follow/compas_dev?style=social)](https://twitter.com/compas_dev)

  The **COMPAS** framework is an open-source, Python-based framework for computational research and collaboration in architecture, engineering, digital fabrication and construction.

  The framework consists of a general-purpose core library, written in pure Python, and a growing collection of extensions that provide easy access to peer-reviewed research, state-of-the-art external libraries such as CGAL, libigl and Triangle, and tools with specialized functionality for AEFC applications such as Abaqus, ANSYS, SOFISTIK, ROS, etc.

  COMPAS has dedicated packages for working with Rhino, Grasshopper, and Blender, but it can be used in any environment that supports Python scripting. It is available on PyPI and conda-forge and can be easily installed using popular package managers on multiple platforms.



  We are working on a new major release of the framework, COMPAS 2.0!
  Therefore, be aware that the current version of the repository already contains some changes that are incompatible with the version 1 releases.
  The documentation of the latest stable version (COMPAS 1.17.9) [is available here](https://compas.dev/compas/1.17.9).



  The recommended way to install **COMPAS** is to use [Anaconda/conda](https://conda.io/docs/):

  ```bash
  conda config --add channels conda-forge
  conda install compas
  ```

  For other installation options, [see the user guide](https://compas.dev/compas/latest/userguide/installation.html)



  * [First steps](https://compas.dev/compas/latest/userguide/firststeps.html)
  * [Tutorials: geometry basics](https://compas.dev/compas/latest/userguide/basics.geometry.html)
  * [Tutorials: datastructures](https://compas.dev/compas/latest/userguide/basics.datastructures.html)
  * [API Reference](https://compas.dev/compas/latest/api/index.html)



  The **COMPAS** framework has a [forum for questions and discussions](https://forum.compas-framework.org/).



  If you find a bug, please help us solve it by [filing a report](https://github.com/compas-dev/compas/issues).



  If you want to contribute, check out the [contribution guidelines](https://compas.dev/compas/latest/devguide/index.html).



  See changes between releases on the [changelog](https://github.com/compas-dev/compas/blob/main/CHANGELOG.md).



  The main library of **COMPAS** is [released under the MIT license](https://compas.dev/compas/latest/userguide/license.html).



  COMPAS is developed by a small team of core developers (`compas-dev`) and with the support of contributers from the open source community.
  See the [list of authors](https://github.com/compas-dev/compas/blob/main/AUTHORS.md) for a complete overview...

rpm_license:
  MIT License  Copyright (c) 2017-2023 COMPAS Association  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: 0d0860f4af48ea615c307935a05e2359eabf96e5cb41d82e55f39157fd298a67
name: python-compconf-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for compconf
url: https://pypi.org/project/compconf/
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-compconf-0.3.0-1.src.rpm
location_href: Packages/python-compconf-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/mmore500/compconf/actions/workflows/ci.yaml/badge.svg)](https://github.com/mmore500/compconf/actions/workflows/python-ci.yaml?query=branch:python)
  [![GitHub stars](https://img.shields.io/github/stars/mmore500/compconf.svg?style=flat-square&logo=github&label=Stars&logoColor=white)](https://github.com/mmore500/compconf)
  [
  ![PyPi](https://img.shields.io/pypi/v/compconf.svg)
  ](https://pypi.python.org/pypi/compconf)

  compconf enables flexible, type-rich comptime configuration of Cerebras Software Language (CSL) projects

  -   Free software: MIT license

  <!---
  -   Documentation: <https://compconf.readthedocs.io>.
  -->



  compconf wraps the `cslc` compiler, forwarding all non-compconf flags.

  ```bash
  python3 -m compconf --compconf-jq '. += {"baz:f32": 42.0}'
  ```

  Access configuration values in csl code using the `compconf` module.
  ```zig
  const compconf = @import("compconf.zig");

  fn main() void {
      @comptime_print(compconf.get_value("baz", f32));
      @comptime_print(compconf.get_value_or("bar", @as(f16, 24.0)));
  }
  ```

  The `compconf` module provides the following functions:
  ```zig
  fn get_value(comptime field_name: comptime_string, comptime T: type) T

  fn get_value_or(
      comptime field_name: comptime_string, comptime default_value: anytype
  ) @type_of(default_value)
  ```

  Available options:
  ```
  usage: __main__.py [-h] [--compconf-cslc COMPCONF_CSLC] [--compconf-data COMPCONF_DATA] [--compconf-jq COMPCONF_JQ] [--compconf-verbose]

  compconf enables flexible, type-rich comptime configuration of csl projects.

  options:
    -h, --help            show this help message and exit
    --compconf-cslc COMPCONF_CSLC
                          compiler command to run
    --compconf-data COMPCONF_DATA
                          json data file to read, if any
    --compconf-jq COMPCONF_JQ
                          jq command to add/modify data (e.g., '. += {"foo:u32": 42}')
    --compconf-verbose    enable verbose logging

  JSON data must be formatted according to `@import_comptime_value` conventions. See <https://sdk.cerebras.net/csl/language/builtins#import-comptime-value> DISCLAIMER: Cerebras Software
  Language is the intellectual property of Cerebras Systems, Inc. This project is not an official Cerebras project and is not affiliated with or endorsed by Cerebras Systems, Inc. in any
  way. All trademarks, logos, and intellectual property associated with Cerebras Systems remain the exclusive property of Cerebras Systems, Inc.
  ```




  To install from PyPi with pip, run

  `python3 -m pip install compconf`



  Cerebras Software Language is the intellectual property of Cerebras Systems, Inc.
  This project is not an official Cerebras project and is not affiliated with or endorsed by Cerebras Systems, Inc. in any way.
  All trademarks, logos, and intellectual property associated with Cerebras Systems remain the exclusive property of Cerebras Systems, Inc.


pkgId: 4622eef04f75c6cb3f0c315844df46e54a5a46dfeb1167b367053dc29016af2f
name: python-completor-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for completor
url: https://github.com/equinor/completor
rpm_license: LGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-completor-1.1.2-1.src.rpm
location_href: Packages/python-completor-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Completor® is an Equinor developed Python Command Line Interface (CLI) for modeling wells with inflow control technology.


  Completor® reads the multi-segmented tubing definition generated by reservoir modelling pre-processing tool and a user defined file (called "case" file) specifying the completion design.
  The information in the input schedule file and the case file is combined
  and written to a new schedule file to be included in your reservoir simulator.


  Detailed documentation for usage of completor can be found at https://equinor.github.io/completor.




  * [Python](https://www.python.org/), version 3.11
  * [ERT](https://github.com/equinor/ert) (optional, and only available on Linux.)


  To start using Completor®, you can follow these instructions:

  ```shell
  git clone https://github.com/equinor/completor.git
  cd completor
  python3 -m venv venv
  source venv/bin/activate
  pip install -e .
  ```

  If you intend to run completor as a plugin to ert:
  ```shell
  git clone https://github.com/equinor/completor.git
  cd completor
  python -m venv venv
  source venv/bin/activate
  pip install -e ".[ert]"
  ```

  Ensure it runs as intended, confirm it with:
  ```shell
  completor --help
  ```
  This should run for some time and display a help message.


  Some examples of Completor case file are available in [Examples](documentation/docs/about/examples.mdx) and detailed explanation is available in [Configuration](documentation/docs/about/configuration.mdx).



  We welcome all kinds of contributions, including code, bug reports, issues, feature requests, and documentation.
  The preferred way of submitting a contribution is to either make an issue on GitHub or by forking the project on GitHub
  and making a pull request.

  See [Contribution Document](documentation/docs/contribution_guide.mdx) on how to contribute.


  In order to run Completor® you need to have versions of [Python 3.11](https://www.python.org/downloads/) installed.

  Clone the [Completor® repository](https://github.com/equinor/completor) to get the source code.
  ```bash
  git clone https://github.com/equinor/completor.git
  cd completor
  ```


  [Install pipx](https://github.com/pypa/pipx#install-pipx), although it's optional next step assumes pipx is installed, check poetry docs for other installation options.

  Linux:
  ```bash
  python3 -m pip install --user pipx
  python3 -m pipx ensurepath
  ```
  Windows:
  ```bash
  python -m pip install --user pipx

  ```
  Mac:
  ```bash
  brew install pipx
  pipx ensurepath
  ```


  For options other than pipx see [poetry documentation](https://python-poetry.org/docs/main/#installation)
  Open a new terminal/tab then
  ```bash
  pipx install poetry
  ```
  Let Poetry install all dependencies for you.
  ```bash
  poetry install
  ```
  If you're in a Linux environment add the extra Ert dependencies!
  ```bash
  poetry install -E ert
  ```

  Activate poetryenv (or use venv if that is more familiar, poetry should respect it as an environment):
  ```bash
  poetry shell
  ```

  Now you should be able to check that everything is installed correctly by running
  ```bash
  pytest
  ```
  in the activated poetry shell.

  Information regarding integration with PyCharm can be found here: https://www.jetbrains.com/help/pycharm/poetry.html#poetry-env
  More info on viewing your environment information can be found here: https://python-poetry.org/docs/managing-environments/#switching-between-environments

  Poetry support completion scripts for Bash, Fish and Zsh [detailed information can be found here](https://python-poetry.org/docs/#installing-with-pipx).



  This project makes use of pre-commit to ensure commits adhere to certain rules and standards.
  Pre-commit should already be installed in the `poetry install` command, but you need to activate the hooks like so:
  ```bash
  pre-commit install
  ```

  If for some reason this is not working correctly you can install pre-commit separately like this:
  ```bash
  pipx install pre-commit
  pre-commit install
  ```

  Now pre-commit should be a constant nuisance, bothering you with some minor change each time you want to commit.
  Although annoying this is preferable to having lots of minor quirks in the code, such as trailing whitespace everywhere.
  Just run git commit a second time, remembering to add the changes made by pre-commit and you should be mostly good!

  > Git hook scripts are useful for identifying simple issues before submission to code review.
  > Run hooks on every commit to automatically point out issues in code such as missing semicolons, trailing whitespace, and debug statements.
  > By pointing these issues out before code review, this allows a code reviewer to focus on the architecture of a change while not wasting time with trivial style nitpicks.
  > Black will style your code automatically to match the Black code style, and Flake8 will check your code for style, syntax, and logical errors.
  > Remember to add the changes made by the scripts to your commit.



  This project uses [pytest](https://docs.pytest.org/en/stable/) for unit and integration testing.
  Run it before every push to make sure your code is working as intended.
  To run all tests discovered by pytest, run the following command when in the root folder

  Recommended settings/launch args:
  This makes the tests run in parallel and in turn go a bit more brrrr.
  ```bash
  pytest -n auto
  ```


  This project make use of [Release Please](https://github.com/googleapis/release-please) to keep track of versioning.
  By following [conventional commit messages](https://www.conventionalcommits.org/en) (enforced) in PR titles, and squash-merging, the release please workflow will automatically create/update release-PRs based on which change is performed.


  This project uses [Black](https://pypi.org/project/black/) and [Flake8](https://pypi.org/project/flake8/) for code formatting and linting.
  It deviates from the default black config by setting the max line length to 120 characters.

  It might be helpful turn on format-on-save, and make black format your code on save.

  A helpful visual aid is to set rulers in your editor to 120 characters.
  Code should not exceed 120 characters.
  Add this to you `settings.json` to set rulers in VSCode:

  ```json
  {
    "editor.rulers": [
      120
    ],
    "workbench.colorCustomizations": {
      "editorRuler.foreground": "#33779944"
    }
  }
  ```


pkgId: 5ac9ed1fd0dd0c29f5a0546bc87cc6a7cd03cca33dcc6192dc4c4dec54017097
name: python-compose-sdk-help
arch: noarch
version: 0.22.0
epoch: 0
release: 1
summary: Development documents and examples for compose-sdk
url: https://pypi.org/project/compose-sdk/
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-compose-sdk-0.22.0-1.src.rpm
location_href: Packages/python-compose-sdk-help-0.22.0-1.noarch.rpm
checksum_type: sha256
description:
  Compose is a framework for building robust internal apps in just a couple minutes. Create useful apps without writing a single line of frontend code, API endpoints, authentication, validation, or other boilerplate. Just write your backend logic, while Compose abstracts the rest away.

  Learn more at [composehq.com](https://composehq.com).


pkgId: 8aaff064acbcdfa773fe63d30f19e8c432a1d25ef82fd24ce7241195b239c950
name: python-composio-autogen-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-autogen
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-autogen-0.6.1-1.src.rpm
location_href: Packages/python-composio-autogen-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Use Composio to enhance your Autogen workflows with a suite of tools.





  Automatically star a GitHub repository using natural language commands through an Autogen Agent.



  Install Composio Autogen and connect your GitHub account to enable your agents with GitHub functionalities.

  ```bash
  pip install composio-autogen
  composio-cli add github  # Connect your GitHub account
  composio-cli show-apps   # Check all supported apps
  ```





  Setup your environment by importing necessary packages and configuring the Autogen agent.

  ```python
  from autogen import AssistantAgent, UserProxyAgent
  from composio_autogen import ComposioToolSet, App, Action
  import os


  llm_config = {"config_list": [{"model": "gpt-4-turbo", "api_key": os.environ["OPENAI_API_KEY"]}]}


  chatbot = AssistantAgent(
      "chatbot",
      system_message="Reply TERMINATE when the task is done or when user's content is empty",
      llm_config=llm_config,
  )


  user_proxy = UserProxyAgent(
      "user_proxy",
      is_termination_msg=lambda x: x.get("content", "") and "TERMINATE" in x.get("content", ""),
      human_input_mode="NEVER",  # Don't take input from User
      code_execution_config={"use_docker": False}
  )
  ```



  Initialize and register the necessary tools for interacting with GitHub.

  ```python
  from composio_autogen import ComposioToolSet, App, Action


  composio_tools = ComposioToolSet()


  composio_tools.register_tools(tools=[App.GITHUB], caller=chatbot, executor=user_proxy)
  ```



  Perform tasks like starring a repository on GitHub using the configured agent.

  ```python
  task = "Star a repo composiohq/composio on GitHub"


  response = user_proxy.initiate_chat(chatbot, message=task)

  print(response.chat_history)
  ```



  Verify the task completion and response from the agent.

  ```bash
  [{'content': 'I have starred the repository "composio" for you on GitHub under the account "composiohq".', 'role': 'user'},
  {'content': '', 'role': 'assistant'}, {'content': 'TERMINATE', 'role': 'user'}]
  ```



  - **Filter Specific Actions:** Limit the actions an agent can execute to enhance security and focus.

  ```python
  composio_tools.register_tools(actions=[Action.GITHUB_CREATE_ISSUE])
  ```

  - **Filter Specific Apps:** Restrict the agent's access to specific tools for streamlined operations.

  ```python
  composio_tools.register_tools([App.ASANA, App.GITHUB])
  ```


pkgId: cf840f39b234c4c8e3de32d77e009625ffd845ab659fc670067aafe4e10fec19
name: python-composio-camel-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-camel
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-camel-0.6.1-1.src.rpm
location_href: Packages/python-composio-camel-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Facilitate the integration of Camel Agents with Composio to empower the agents to directly interact with external applications, broadening their capabilities and application scope.



  - **Automate starring a GitHub repository** using conversational instructions via Camel's Tool Usage ability.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-camel


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from Composio & Camel.

  ```python
  from colorama import Fore

  from camel.agents import ChatAgent
  from camel.configs import ChatGPTConfig
  from camel.messages import BaseMessage
  from camel.models import ModelFactory
  from camel.types import ModelPlatformType, ModelType
  from camel.utils import print_text_animated
  from composio_camel import ComposioToolSet, Action
  ```



  This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for Camel operations.
  ```python
  composio_toolset = ComposioToolSet()
  tools = composio_toolset.get_actions(
      actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
  )
  ```



  This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.

  ```python

  assistant_model_config = ChatGPTConfig(
      temperature=0.0,
      tools=tools,
  )

  model = ModelFactory.create(
      model_platform=ModelPlatformType.OPENAI,
      model_type=ModelType.GPT_3_5_TURBO,
      model_config_dict=assistant_model_config.__dict__,
  )



  assistant_sys_msg = BaseMessage.make_assistant_message(
      role_name="Developer",
      content=(
          "You are a programmer as well an experienced github user. "
          "When asked given a instruction, "
          "you try to use available tools, and execute it"
      ),
  )

  agent = ChatAgent(
      assistant_sys_msg,
      model,
      tools=tools,
  )
  agent.reset()
  ```



  Execute the following code to execute the agent, ensuring that the intended task has been successfully completed.

  ```python
  prompt = (
      "I have created a new Github Repo,"
      "Please star my github repository: camel-ai/camel"
  )
  user_msg = BaseMessage.make_user_message(role_name="User", content=prompt)
  print(Fore.YELLOW + f"user prompt:\n{prompt}\n")

  response = agent.step(user_msg)
  for msg in response.msgs:
      print_text_animated(Fore.GREEN + f"Agent response:\n{msg.content}\n")

  ```


pkgId: 15a10d11314b41c7a698fed217f3da71c53506169423432ffdb75962d4efddfe
name: python-composio-claude-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-claude
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-claude-0.6.1-1.src.rpm
location_href: Packages/python-composio-claude-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Facilitate the integration of Claude with Composio to empower Claude models to directly interact with external applications, broadening their capabilities and application scope.



  - **Automate starring a GitHub repository** using conversational instructions via Claude Function Calls.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-claude


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from Claude and setting up your client.

  ```python
  import anthropic


  client = anthropic.Anthropic()
  ```



  This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for LangChain operations.
  ```python
  from composio_claude import App, ComposioToolSet

  toolset = ComposioToolSet()
  actions = toolset.get_tools(tools=App.GITHUB)
  ```



  This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.

  ```python
  my_task = "Star a repo composiohq/composio on GitHub"


  response = client.beta.tools.messages.create(
      model="claude-3-opus-20240229",
      max_tokens=1024,
      tools= actions,
      messages=[{"role": "user", "content": "Star me composiohq/composio repo in github."}],
  )
  pprint(response)
  ```



  Execute the following code to validate the response, ensuring that the intended task has been successfully completed.

  ```python
  result = toolset.handle_tool_calls(response)
  pprint(result)
  ```


pkgId: 0953dd8a4f63ac5bcc0d5955296784ccbfdb2ff2a39c3a6605c30ad376d34e53
name: python-composio-core-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-core
url: https://github.com/composiohq/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-core-0.6.1-1.src.rpm
location_href: Packages/python-composio-core-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://x.com/GanatraSoham/?utm_campaign=github-readme" target="_blank">
      <img src="./python/docs/imgs/follow_x.png" width="100%" alt="Follow me" />
    </a>
    <br /> <br />
  </p>
  <p align="center">
    <a href="https://app.composio.dev/?utm_campaign=github-readme" target="_blank">
      <img src="./python/docs/imgs/try_hosted.png" width="100%" alt="Sign up" />
    </a>

    <br /> <br />
  </p>
  <p>
    <a href="https://github.com/composiohq/composio/blob/master/README.md">EN</a> | <a href="https://github.com/composiohq/composio/blob/master/README-CN.md">CN</a> | <a href="https://github.com/composiohq/composio/blob/master/README-JP.md">JP</a>
  </p>

  <p align="center">
    <a href="https://composio.dev//#gh-dark-mode-only">
      <img src="./python/docs/imgs/composio_white_font.svg" width="318px" alt="Composio logo" />
    </a>
    <a href="https://composio.dev//#gh-light-mode-only">
      <img src="./python/docs/imgs/composio_black_font.svg" width="318px" alt="Composio Logo" />
    </a>
  </p>
  <p align="center">
    <a href="https://github.com/composiodev/composio/actions/workflows/common.yml">
    <img alt="Tests" src="https://img.shields.io/github/actions/workflow/status/composiodev/composio/common.yml?label=Tests&style=plastic&logo=github&color=blue&cacheSeconds=60">
    </a>
    <a href="https://pypi.org/project/composio-core/">
    <img alt="PyPI" src="https://img.shields.io/pypi/v/composio_core?label=Latest&style=plastic&logo=pypi&color=blue&cacheSeconds=60&logoColor=white">
    </a>
    <a href="https://www.npmjs.com/package/composio-core">
    <img alt="NPM" src="https://img.shields.io/npm/v/composio-core?style=plastic&logo=npm&logoColor=white&label=latest&color=blue&cacheSeconds=60">
    </a>
    <a href="https://pypi.org/project/composio-core/">
    <img alt="Downloads" src="https://img.shields.io/pypi/dm/composio-core?label=Downloads&style=plastic&logo=github&color=blue&cacheSeconds=60">
    </a>

  </p>

  <h2 align="center"><i>
    Production Ready Toolset for AI Agents
  </i></h2>

  <h4 align="center">Equip your agent with high-quality tools & integrations without worrying about authentication, accuracy, and reliability in a single line of code!
  </h4>
  <div align="center">
  <p>
  <a href="https://docs.composio.dev" rel="dofollow"><strong>Explore the Docs »</strong></a>
  </p>

  <p>
  <a href="https://app.composio.dev">Try on Dashboard</a> <b>|</b>
  <a href="https://www.composio.dev">Homepage</a> <b>|</b>
  <!-- <a href="https://docs.composio.dev/guides/examples">Examples</a> |
  <a href="https://docs.composio.dev/chat-with-docs">Chat with Docs</a> | -->
  <a href="https://docs.composio.dev/sdk">SDK</a> <b>|</b>
  <a href="https://docs.composio.dev/api-reference/">APIs</a>
  </p>
  </div>

  <hr>
  <div align="center">
  <p >
      <b>✨ Socials >></b>
      <a href="https://dub.composio.dev/JoinHQ">Discord</a> <b>|</b>
      <a href="https://www.youtube.com/@Composio">Youtube</a> <b>|</b>
      <a href="https://twitter.com/composiohq">Twitter</a> <b>|</b>
      <a href="https://www.linkedin.com/company/composio-dev"> Linkedin </a>
  </p>
  <p align="center">
      <b>⛏️ Contribute >></b>
      <a href="https://github.com/composiodev/composio/issues/new?assignees=&labels=type%3A+bug&template=bug_report.yml&title=%F0%9F%90%9B+Bug+Report%3A+">Report Bugs</a> <b>|</b>
      <a href="https://github.com/composiodev/composio/issues/new?assignees=&labels=feature&template=feature_request.yml&title=%F0%9F%9A%80+Feature%3A+">Request Feature</a> <b>|</b>
      <a href="https://github.com/composiodev/composio/blob/master/CONTRIBUTING.md">Contribute</a>
  </p>
  </div>



  - [📋 Table of contents](#-table-of-contents)
  - [🤔 Why Composio?](#-why-composio)
  - [🔥 Key Features](#-key-features)
  - [🚀 Getting Started with Python](#-getting-started-with-python)
    - [1. Installation](#1-installation)
    - [2. Testing Composio in Action](#2-testing-composio-in-action)
  - [🚀 Getting Started with Javascript](#-getting-started-with-javascript)
    - [1. **Install the Composio SDK**:](#1-install-the-composio-sdk)
    - [2. **Setup the OpenAI and Composio Tool Set**:](#2-setup-the-openai-and-composio-tool-set)
    - [3. **Run your script**:](#3-run-your-script)
  - [💡 Examples](#-examples)
    - [Python Examples](#python-examples)
    - [Javascript Examples](#javascript-examples)
  - [Star History](#star-history)
  - [📋 Read Our Code Of Conduct](#-read-our-code-of-conduct)
  - [🤗 Contributions](#-contributions)
  - [🔗 Links](#-links)
  - [🛡️ License](#️-license)
  - [💪 Thanks To All Contributors](#-thanks-to-all-contributors)



  We believe AI Based Agents/Workflows are the future.
  Composio is the best toolset to integrate AI Agents to best Agentic Tools and use them to accomplish tasks.

  <img alt="Illustration" src="./python/docs/imgs/banner.gif" style="border-radius: 5px"/>



  - **100+ Tools**: Support for a range of different categories

    - **Software**: Do anything on GitHub, Notion, Linear, Gmail, Slack, Hubspot, Salesforce, & 90 more.
    - **OS**: Click anywhere, Type anything, Copy to Clipboard, & more.
    - **Browser**: Smart Search, Take a screenshot, MultiOn, Download, Upload, & more.
    - **Search**: Google Search, Perplexity Search, Tavily, Exa & more.
    - **SWE**: Ngrok, Database, Redis, Vercel, Git, etc.
    - **RAG**: Agentic RAG for any type of data on the fly!

  - **Frameworks**: Use tools with agent frameworks like **OpenAI, Groq (OpenAI compatible), Claude, LlamaIndex, Langchain, CrewAI, Autogen, Gemini, Julep, Lyzr**, and more in a single line of code.
  - **Managed Authorisation**: Supports six different auth protocols. _Access Token, Refresh token, OAuth, API Keys, JWT, and more_ abstracted out so you can focus on the building agents.
  - **Accuracy**: Get _up to 40% better agentic accuracy_ in your tool calls due to better tool designs.
  - **Embeddable**: Whitelabel in the backend of your applications managing Auth & Integrations for all your users & agents and maintain a consistent experience.
  - **Pluggable**: Designed to be extended with additional Tools, Frameworks and Authorisation Protocols very easily.





  To get started, type the following command in your Terminal.

  ```bash
  pip install composio-core
  ```

  If you want to install the 'composio' package along with its openai plugin: `pip install composio-openai`.



  Let's use Composio to create an AI Agent that can star a Github Repo.

  ```bash
  composio add github # Connect your Github - Run this in terminal
  ```

  ```python

  from openai import OpenAI
  from composio_openai import ComposioToolSet, App, Action

  openai_client = OpenAI(
      api_key="{{OPENAIKEY}}"
  )



  composio_tool_set = ComposioToolSet()


  actions = composio_tool_set.get_actions(
      actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
  )

  my_task = "Star a repo composiodev/composio on GitHub"


  assistant_instruction = "You are a super intelligent personal assistant"

  assistant = openai_client.beta.assistants.create(
      name="Personal Assistant",
      instructions=assistant_instruction,
      model="gpt-4-turbo",
      tools=actions,
  )


  thread = openai_client.beta.threads.create()

  message = openai_client.beta.threads.messages.create(
      thread_id=thread.id,
      role="user",
      content=my_task
  )


  run = openai_client.beta.threads.runs.create(
      thread_id=thread.id,
      assistant_id=assistant.id
  )



  response_after_tool_calls = composio_tool_set.wait_and_handle_assistant_tool_calls(
      client=openai_client,
      run=run,
      thread=thread,
  )

  print(response_after_tool_calls)
  ```



  To get started with the Composio SDK in Javascript, follow these steps:


     ```bash
     npm install composio-core
     ```


     ```javascript
     import { OpenAI } from "openai";
     import { OpenAIToolSet } from "composio-core";

     const toolset = new OpenAIToolSet({
         apiKey: process.env.COMPOSIO_API_KEY,
     });

     async function setupUserConnectionIfNotExists(entityId) {
         const entity = await toolset.client.getEntity(entityId);
         const connection = await entity.getConnection('github');

         if (!connection) {
             // If this entity/user hasn't already connected the account
             const connection = await entity.initiateConnection(appName);
             console.log("Log in via: ", connection.redirectUrl);
             return connection.waitUntilActive(60);
         }

         return connection;
     }

     async function executeAgent(entityName) {
         const entity = await toolset.client.getEntity(entityName)
         await setupUserConnectionIfNotExists(entity.id);

         const tools = await toolset.get_actions({ actions: ["github_issues_create"] }, entity.id);
         const instruction = "Make an issue with sample title in the repo - himanshu-dixit/custom-repo-breaking"

         const client = new OpenAI({ apiKey: process.env.OPEN_AI_API_KEY })
         const response = await client.chat.completions.create({
             model: "gpt-4-turbo",
             messages: [{
                 role: "user",
                 content: instruction,
             }],
             tools: tools,
             tool_choice: "auto",
         })

         console.log(response.choices[0].message.tool_calls);
         await toolset.handle_tool_call(response, entity.id);
     }

     executeAgent("your-entity-name");
     ```


     ```bash
     node your_script.js
     ```

  This will set up the Composio SDK and execute an agent that creates a GitHub issue using the provided instructions.

  For more details, refer to the [Composio SDK Documentation](https://docs.composio.dev/).












  [![Star History Chart](https://api.star-history.com/svg?repos=composiohq/composio&type=Date)](https://star-history.com/#composiohq/composio&Date)




  As part of our open-source community, we hold ourselves and other contributors to a high standard of communication. As a participant and contributor to this project, you agree to abide by our [Code of Conduct](https://github.com/composiodev/composio/blob/master/CODE_OF_CONDUCT.md).



  Composio is open-source and we welcome contributions. Please fork the repository, create a new branch for your feature, add your feature or improvement, and send a pull request.

  Also go through our [Contribution Guidelines](https://github.com/composiodev/composio/blob/master/CONTRIBUTING.md) and [Code of Conduct](https://github.com/composiodev/composio/blob/master/CODE_OF_CONDUCT.md) before you start.



  - [Home page](https://composio.dev?utm_campaign=github-readme)
  - [Contribution Guidelines](https://github.com/composiodev/composio/blob/master/CONTRIBUTING.md)
  - [Docs](https://docs.composio.dev/?utm_campaign=github-readme)



  Composio is licensed under the Elastic License - see the [LICENSE](https://github.com/composiodev/composio/blob/master/LICENSE) file for details.



  <a href="https://github.com/composiohq/composio/graphs/contributors">
    <img src="https://contributors-img.web.app/image?repo=composiodev/composio" alt="List of Contributors"/>
  </a>


pkgId: 73bfd8cab8d8b62f273134844a10b2d7f4d4e1c5031e39a1f48c422ec2b5f034
name: python-composio-crewai-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-crewai
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-crewai-0.6.1-1.src.rpm
location_href: Packages/python-composio-crewai-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  ![CrewAI Logo](https://i.imgur.com/jXeNUda.png)

  **Composio** enables **CrewAI agents** to connect with numerous tools, making it easy for these agents to interact with external applications seamlessly.



  Start by installing Composio CrewAI and connecting your GitHub account to enable GitHub functionalities for your agents.

  ```bash
  pip install composio_crewai
  composio-cli add github  # Connect your GitHub account
  composio-cli show-apps   # Check available applications
  ```



  Automate GitHub interactions, such as starring a repository, using natural language commands through a CrewAI Agent.





  Prepare your environment by importing the necessary packages for CrewAI and setting up your language model.

  ```python
  from crewai import Agent, Task
  from langchain_openai import ChatOpenAI


  llm = ChatOpenAI(openai_api_key="sk-<OPENAI KEY>")
  ```



  Initialize the Composio toolset for interacting with GitHub.

  ```python
  from composio_crewai import ComposioToolSet, Action, App


  tools = ComposioToolSet(apps=[App.GITHUB])
  ```



  Configure and execute the CrewAI agent to perform GitHub actions.

  ```python
  crewai_agent = Agent(
      role='Github Agent',
      goal="You take action on Github using Github APIs",
      backstory="You are an AI agent responsible for taking actions on Github on users' behalf using Github APIs",
      verbose=True,
      tools=tools,
      llm=llm
  )


  task = Task(
      description="Star a repo composiohq/composio on GitHub",
      agent=crewai_agent,
      expected_output="if the star happened"
  )


  task.execute()
  ```



  Verify the agent's actions and responses to ensure the task was completed successfully.

  ```bash
  > Entering new CrewAgentExecutor chain...
  > I need to star the repository "composiohq/composio" on GitHub.
  > {'execution_details': {'executed': True}, 'response_data': ''}
  > Finished chain.
  ```



  - **Filter Specific Actions:** Limit the actions an agent can perform for enhanced security and operational focus.

  ```python
  toolsGithubCreateIssue = ComposioToolSet(actions=[Action.GITHUB_CREATE_ISSUE])
  ```

  - **Filter Specific Apps:** Restrict the agent's access to certain applications for streamlined operations.

  ```python
  toolsAsanaGithub = ComposioToolSet(apps=[App.ASANA, App.GITHUB])
  ```


pkgId: 29ff27e0e8d6bd68c8db1d2e51c6c501cc80390bd0d2f5948a2503104ca77858
name: python-composio-google-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-google
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-google-0.6.1-1.src.rpm
location_href: Packages/python-composio-google-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Streamline the integration of Composio with Google AI Python to enhance the capabilities of Gemini models, allowing them to interact directly with external applications and expanding their operational scope.



  - **Automate starring a GitHub repository** using conversational instructions via Google AI Python's Function Calling feature.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-google


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from Google AI Python and setting up your client.

  ```python
  from vertexai.generative_models import GenerativeModel


  model = GenerativeModel("gemini-pro")
  ```



  This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for Google AI Python operations.
  ```python
  from composio_google import App, ComposioToolset

  toolset = ComposioToolset()
  actions = toolset.get_tools(apps=[App.GITHUB])
  ```



  This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.

  ```python

  task = "Star a repo composiohq/composio on GitHub"


  response = chat.send_message(task)
  ```



  Execute the following code to validate the response, ensuring that the intended task has been successfully completed.

  ```python
  result = composio_toolset.handle_response(response)
  print("Function call result:", result)
  ```


pkgId: 8263ec21075431868e2a7caa71550c8dad70e9a0859b2dd7115b1033bd78b03b
name: python-composio-griptape-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-griptape
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-griptape-0.6.1-1.src.rpm
location_href: Packages/python-composio-griptape-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Streamline the integration of Composio within the Griptape agentic framework to enhance the interaction capabilities of Griptape agents with external applications, significantly extending their operational range and efficiency.



  - **Facilitate the automation of starring a GitHub repository** through the use of conversational commands within the Griptape framework, leveraging Composio's Function Calls.




  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-griptape


  composio-cli add github


  composio-cli show-apps
  ```





  Establish your development environment by importing necessary libraries and setting up the Griptape client.
  ```python
  from griptape.structures import Agent
  from griptape.utils import Chat

  from composio_griptape import App, Action, Tag, ComposioToolSet
  import dotenv


  dotenv.load_dotenv("/Users/sawradip/Desktop/practice_code/practice_composio/composio_sdk/examples/.env")

  ```



  This section guides you through the process of integrating GitHub tools into your Griptape projects using Composio's services.

  ```python
  composio_toolset = ComposioToolSet()
  composio_tools = composio_toolset.get_tools(tools = App.GITHUB)

  agent = Agent(
      tools=composio_tools
  )
  ```



  This step involves configuring and Chatting with the Griptape agent to carry out specific tasks, for example, starring a GitHub repository.

  ```python
  Chat(agent).start()
  ```


pkgId: 44f6d71245a25ae397c042dfa0d9151a17343e5380fd8d86bffe02adaae99221
name: python-composio-julep-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-julep
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-julep-0.6.1-1.src.rpm
location_href: Packages/python-composio-julep-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Streamline the integration of Composio within the Julep agentic framework to enhance the interaction capabilities of Julep agents with external applications, significantly extending their operational range and efficiency.



  - **Facilitate the automation of starring a GitHub repository** through the use of conversational commands within the Julep framework, leveraging Composio's OpenAI Function Calls.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-openai


  composio-cli add github


  composio-cli show-apps
  ```





  Set up your development environment by importing essential libraries and configuring the Julep client.
  ```python

  import os
  import textwrap
  from julep import Client
  from dotenv import load_dotenv


  load_dotenv()

  api_key = os.environ["JULEP_API_KEY"]
  base_url = os.environ["JULEP_API_URL"]


  client = Client(api_key=api_key, base_url=base_url)



  name = "Jessica"
  about = "Jessica is a forward-thinking tech entrepreneur with a sharp eye for disruptive technologies. She excels in identifying and nurturing innovative tech startups, with a particular interest in sustainability and AI."
  default_settings = {
      "temperature": 0.7,
      "top_p": 1,
      "min_p": 0.01,
      "presence_penalty": 0,
      "frequency_penalty": 0,
      "length_penalty": 1.0,
      "max_tokens": 150,
  }
  ```



  This section guides you through the process of integrating GitHub tools into your LangChain projects using Composio's services.
  ```python
  from composio_julep import App, ComposioToolSet

  toolset = ComposioToolSet()
  composio_tools = toolset.get_tools(tools=App.GITHUB)


  agent = client.agents.create(
      name=name,
      about=about,
      default_settings=default_settings,
      model="gpt-4-turbo",
      tools=composio_tools,
  )
  ```



  This step involves configuring and executing the agent to carry out specific tasks, for example, starring a GitHub repository.
  ```python
  about = """
  Sawradip, a software developer, is passionate about impactful tech.
  At the tech fair, he seeks investors and collaborators for his project.
  """
  user = client.users.create(
      name="Sawradip",
      about=about,
  )

  situation_prompt = """You are Jessica, a key figure in the tech community, always searching for groundbreaking technologies. At a tech fair filled with innovative projects, your goal is to find and support the next big thing.

  Your journey through the fair is highlighted by encounters with various projects, from groundbreaking to niche. You believe in the power of unexpected innovation.

  Recent Tweets
  1. 'Amazed by the tech fair's creativity. The future is bright. #TechInnovation'
  2. 'Met a developer with a transformative tool for NGOs. This is the
  """

  session = client.sessions.create(
      user_id=user.id, agent_id=agent.id, situation=situation_prompt
  )

  user_msg = "Hi, I am presenting my project, hosted at github repository composiohq/composio. If you like it, adding a star would be helpful "



  response = client.sessions.chat(
      session_id=session.id,
      messages=[
          {
              "role": "user",
              "content": user_msg,
              "name": "Sawradip",
          }
      ],
      recall=True,
      remember=True,
  )

  pprint(response)
  ```



  Execute and validate the response to ensure the task was completed successfully.

  ```python
  execution_output = toolset.handle_tool_calls(response)
  print(execution_output)
  ```


pkgId: c7a8aa6f7f476e6ac668f066b2ff6784228173f922d2aebe997720f471a5e8d6
name: python-composio-langchain-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-langchain
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-langchain-0.6.1-1.src.rpm
location_href: Packages/python-composio-langchain-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Integrate Composio with LangChain agents to allow them to interact seamlessly with external apps, enhancing their functionality and reach.



  - **Star a repository on GitHub** using natural language commands through a LangChain Agent.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-langchain


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from LangChain and setting up your agent.

  ```python
  from langchain.agents import create_openai_functions_agent, AgentExecutor
  from langchain import hub
  from langchain_openai import ChatOpenAI


  llm = ChatOpenAI()


  prompt = hub.pull("hwchase17/openai-functions-agent")
  ```



  Access GitHub tools provided by Composio for LangChain.

  ```python
  from composio_langchain import ComposioToolSet, Action, App


  tools = ComposioToolSet(apps=[App.GITHUB])
  ```



  Configure and execute the agent to perform tasks such as starring a repository on GitHub.

  ```python
  task = "Star a repo composiohq/composio on GitHub"


  agent = create_openai_functions_agent(llm, tools, prompt)
  agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)


  agent_executor.invoke({"input": task})
  ```



  Validate the execution and response from the agent to ensure the task was completed successfully.

  ```bash
  > Entering new AgentExecutor chain...
  > Invoking: `github_star_repo` with `{'owner': 'composiohq', 'repo': 'composio'}`
  > {'execution_details': {'executed': True}, 'response_data': ''}
  > I have successfully starred the repository composiohq/composio on GitHub.
  ```



  - **Filter Specific Actions:** Limit the actions an agent can execute.

  ```python

  toolsGithubCreateIssue = ComposioToolSet(actions=[Action.GITHUB_CREATE_ISSUE])
  ```

  - **Filter Specific Apps:** Restrict the tools an agent can use.

  ```python

  toolsAsanaGithub = ComposioToolSet(apps=[App.ASANA, App.GITHUB])
  ```


pkgId: fe640f9738593e15c9d4b66d5113e2560ce7d48c4278ebcb89d59685961c8111
name: python-composio-langgraph-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-langgraph
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-langgraph-0.6.1-1.src.rpm
location_href: Packages/python-composio-langgraph-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Integrate Composio with LangGraph Agentic workflows & enable them to interact seamlessly with external apps, enhancing their functionality and reach.



  - **Star a repository on GitHub** using natural language commands through a LangGraph Agent.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-langgraph


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from LangGraph & LangChain for setting up your agent.

  ```python
  from typing import Literal

  from langchain_openai import ChatOpenAI
  from langgraph.graph import MessagesState, StateGraph
  from langgraph.prebuilt import ToolNode
  ```



  Access GitHub tools provided by Composio for LangGraph, initialize a `ToolNode` with necessary tools obtaned from `ComposioToolSet`.

  ```python
  from composio_langgraph import Action, ComposioToolSet


  composio_toolset = ComposioToolSet()
  tools = composio_toolset.get_actions(
      actions=[
          Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER,
          Action.GITHUB_USERS_GET_AUTHENTICATED,
      ])
  tool_node = ToolNode(tools)
  ```



  Initialize the LLM class and bind obtained tools to the model.

  ```python
  model = ChatOpenAI(temperature=0, streaming=True)
  model_with_tools = model.bind_tools(functions)
  ```


  LangGraph expects you to define different nodes of the agentic workflow as separate functions. Here we define a node for calling the LLM model.

  ```python
  def call_model(state: MessagesState):
      messages = state["messages"]
      response = model_with_tools.invoke(messages)
      return {"messages": [response]}
  ```


  To establish the agent's workflow, we begin by initializing the workflow with `agent` and `tools` node, followed by specifying the connecting edges between nodes, finally compiling the workflow. These edges can be straightforward or conditional, depending on the workflow requirements.

  ```python
  def should_continue(state: MessagesState) -> Literal["tools", "__end__"]:
      messages = state["messages"]
      last_message = messages[-1]
      if last_message.tool_calls:
          return "tools"
      return "__end__"


  workflow = StateGraph(MessagesState)


  workflow.add_node("agent", call_model)
  workflow.add_node("tools", tool_node)

  workflow.add_edge("__start__", "agent")
  workflow.add_conditional_edges(
      "agent",
      should_continue,
  )
  workflow.add_edge("tools", "agent")

  app = workflow.compile()
  ```


  After the compilation of workflow, we invoke the LLM with a task, and stream the response.

  ```python
  for chunk in app.stream(
      {
          "messages": [
              (
                  "human",
                  
                  "Get my information.",
              )
          ]
      },
      stream_mode="values",
  ):
      chunk["messages"][-1].pretty_print()
  ```


pkgId: 03cc1baee75ddb8ea53066b503cb464aa5c78c1281f2d7d2df07646c28466d83
name: python-composio-llamaindex-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-llamaindex
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-llamaindex-0.6.1-1.src.rpm
location_href: Packages/python-composio-llamaindex-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Integrate Composio with llamaindex agents to allow them to interact seamlessly with external apps & data sources, enhancing their functionality and reach.



  - **Star a repository on GitHub** using natural language commands through a llamaindex Agent.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-llamaindex


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from llamaindex and setting up your agent.

  ```python
  from llama_index.llms.openai import OpenAI
  from llama_index.core.llms import ChatMessage
  from llama_index.core.agent import FunctionCallingAgentWorker

  import dotenv
  from llama_index.core.tools import FunctionTool


  dotenv.load_dotenv()

  llm = OpenAI(model="gpt-4-turbo")
  ```



  Access GitHub tools provided by Composio for llamaindex.

  ```python
  from composio_llamaindex import App, Action, ComposioToolSet


  composio_toolset = ComposioToolSet()
  tools = composio_toolset.get_actions(
      actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
  )
  print(tools)
  ```



  Configure the agent to perform tasks such as starring a repository on GitHub.

  ```python

  prefix_messages = [
      ChatMessage(
          role="system",
          content=(
              "You are now a integration agent, and what  ever you are requested, you will try to execute utilizing your toools."
          ),
      )
  ]

  agent = FunctionCallingAgentWorker(
      tools=tools,
      llm=llm,
      prefix_messages=prefix_messages,
      max_function_calls=10,
      allow_parallel_tool_calls=False,
      verbose=True,
  ).as_agent()
  ```



  Validate the execution and response from the agent to ensure the task was completed successfully.

  ```bash
  response = agent.chat("Hello! I would like to star a repo composiohq/composio on GitHub")
  print("Response:", response)
  ```


pkgId: c01acf9f415c5a496f005d43731baaabce70db80f9178d7bba3e5722952f2245
name: python-composio-lyzr-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-lyzr
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-lyzr-0.6.1-1.src.rpm
location_href: Packages/python-composio-lyzr-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Integrate Composio with Lyzr agents to allow them to interact seamlessly with external apps, enhancing their functionality and reach.



  - **Star a repository on GitHub** using natural language commands through a LangChain Agent.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-lyzr


  composio-cli add github


  composio-cli show-apps
  ```



  ```
  from  lyzr_automata  import  Task, Agent
  from lyzr_automata.ai_models.openai import OpenAIModel
  from lyzr_automata.tasks.task_literals import InputType, OutputType
  from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline

  import os
  import dotenv
  dotenv.load_dotenv()
  from composio_lyzr import ComposioToolSet, App, Action

  open_ai_text_completion_model = OpenAIModel(
      api_key=os.environ["OPENAI_API_KEY"],
      parameters={
          "model": "gpt-4-turbo-preview",
          "temperature": 0.2,
          "max_tokens": 1500,
      },
  )


  lyzr_agent = Agent(
          role="Github Agent",
          prompt_persona="You are AI agent that is responsible for taking actions on Github on users behalf. You need to take action on Github using Github APIs"
      )

  composio_toolset = ComposioToolSet()
  composio_tool = composio_toolset.get_lyzr_tool(Action.GITHUB_STAR_REPO)

  task = Task(
          name="Github Starring",
          agent=lyzr_agent,
          tool=composio_tool,
          output_type=OutputType.TEXT,
          input_type=InputType.TEXT,
          model=open_ai_text_completion_model,
          instructions="Star a repo composiohq/composio on GitHub",
          log_output=True,
          enhance_prompt=False,
  )

  lyzr_output = LinearSyncPipeline(
      name="Composio Lyzr",
  		
      completion_message="Task completed",
      tasks=[
  				
          task,
      ],
  ).run()

  print(lyzr_output)
  ```


pkgId: 404d50be65fb98465f507a7a738c04ccbc6a2dd58713b85a04d1da4c9116300f
name: python-composio-openai-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-openai
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-openai-0.6.1-1.src.rpm
location_href: Packages/python-composio-openai-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Facilitate the integration of OpenAI with Composio to empower OpenAI models to directly interact with external applications, broadening their capabilities and application scope.



  - **Automate starring a GitHub repository** using conversational instructions via OpenAI Function Calls.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-openai


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from OpenAI and setting up your client.

  ```python
  from openai import OpenAI


  openai_client = OpenAI()
  ```



  This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for LangChain operations.
  ```python
  from composio_openai import App, ComposioToolSet

  toolset = ComposioToolSet()
  actions = toolset.get_tools(apps=[App.GITHUB])
  ```



  This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.

  ```python
  my_task = "Star a repo composiohq/composio on GitHub"


  response = openai_client.chat.completions.create(model="gpt-4-turbo-preview",
      tools=actions, # Passing actions we fetched earlier.
      messages=[
              {"role": "system", "content": "You are a helpful assistant."},
              {"role": "user", "content": my_task}
          ]
      )

  pprint(response)
  ```



  Execute the following code to validate the response, ensuring that the intended task has been successfully completed.

  ```python
  result = toolset.handle_tool_calls(response)
  pprint(result)
  ```


pkgId: 56ffca9654b6c5683d750929ee22c389e6254fb5a24f7e47255b8404baca31c4
name: python-composio-phidata-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-phidata
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-phidata-0.6.1-1.src.rpm
location_href: Packages/python-composio-phidata-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Facilitate the integration of PhiData with Composio to empower LLMs to directly interact with external applications & knowledge base, broadening their capabilities and application scope.



  - **Automate starring a GitHub repository** using conversational instructions via PhiData Tool Calls.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-phidata


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from PhiData.

  ```python
  from phi.assistant import Assistant
  ```



  This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for LangChain operations.
  ```python
  from composio_phidata import ComposioToolSet, Action

  toolset = ComposioToolSet()
  composio_tools = toolset.get_actions(actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER])
  ```



  This step involves configuring and executing the assistant to carry out actions, such as starring a GitHub repository.

  ```python
  my_task = "Star a repo composiohq/composio on GitHub"


  assistant = Assistant(tools=composio_tools, show_tool_calls=True)

  assistant.print_response("Can you star ComposioHQ/composio repo?")
  ```


pkgId: 4cda5f8c301d95a691bf9f2f617feae9d4ef3a3a09ac37e5eaac5533857f75b4
name: python-composio-praisonai-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for composio-praisonai
url: https://github.com/ComposioHQ/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-composio-praisonai-0.6.1-1.src.rpm
location_href: Packages/python-composio-praisonai-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Facilitate the integration of PraisonAI with Composio to empower Praison Agents to directly interact with external applications, broadening their capabilities and application scope.



  - **Automate starring a GitHub repository** using conversational instructions via PraisonAI Agents.



  Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.

  ```bash

  pip install composio-praisonai


  composio-cli add github


  composio-cli show-apps
  ```





  Prepare your environment by initializing necessary imports from Praison and setting up your client.

  ```python
  import os
  import yaml
  from praisonai import PraisonAI
  ```



  This step involves fetching and integrating GitHub tools provided by Composio, and writing them in Praison supported Format, returning the name of tools in a format, that should be added to `agents.yml` file.
  ```python
  from composio_praisonai import Action, ComposioToolSet

  composio_toolset = ComposioToolSet()
  tools = composio_toolset.get_actions(
      actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER]
  )

  tool_section_str = composio_toolset.get_tools_section(tools)
  print(tool_section_str)
  ```



  This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.

  ```python
  agent_yaml = """
  framework: "crewai"
  topic: "Github Management"

  roles:
    developer:
      role: "Developer"
      goal: "An expert programmer"
      backstory: "A developer exploring new codebases and have certain tools available to execute different tasks."
      tasks:
        star_github:
          description: "Star a repo composiohq/composio on GitHub"
          expected_output: "Response whether the task was executed."
  """ + tool_section_str

  print(agent_yaml)
  ```



  Here you initialize PraisonAI class, and execute.
  ```python

  praison_ai = PraisonAI(agent_yaml=agent_yaml)


  result = praison_ai.main()


  print(result)
  ```


pkgId: d54dc62a5e9ef4f5e1c00532bdabcf81db4d103978f5c5287a32fae38f4ca309
name: python-compudoc-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for compudoc
url: https://pypi.org/project/compudoc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-compudoc-0.7.0-1.src.rpm
location_href: Packages/python-compudoc-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  Add the power of python to your LaTeX, Markdown, and more...



  Compudoc is a project with similar goals to [pythontex](https://github.com/gpoore/pythontex), [Codebraid](https://codebraid.org/),
  [pweave](https://mpastell.com/pweave/) and [pyptex](https://pypi.org/project/pyptex/). It is most similar to
  pyptex, and if I had found pyptex earlier, I may not have written Compudoc.

  Features include:

  - Like pyptex, compudoc is a preprocessor. All Python code is executed and replaced before LaTeX, Pandoc, mdSlides, etc is ran. You could use it to render Python files if you wanted.
  - As a preprocessor, compudoc can be used with all your existing tooling. Just run compudoc to produce the source file that would normally go into your pipeline.
  - Unlike pyptex, compudoc is not specific to LaTeX. Any text file can be rendered. LaTeX, Markdown, ReStructuredText, etc. can be rendered with Compudoc.
  - Jinja2 is used for injecting values from Python into the source document. That means you can use Jinja2 filters to make common formatting task cleaner.
  - Python code is executed in a separate interactive Python instance and incrementally between chunks of document text. That means you can define a variable `x` in
    one block of Python code, use that value in a Jinja2 template in your document, change the value of `x` in a later code block, and use it again in the document.
    The value inserted into the document will be the value of `x` at the point it is inserted.
  - Python code is embedded in the comments of your source document, so you can still run the unrendered source file through your toolchain.
  - If the source file you are rending does not support comments (there is no standard way to put comments in Markdown), you can define your own comment line
    identifier and have Compudoc strip them during the render process. This means you can use Compudoc to render any plain text source file without the
    final tool knowing anything about it.



  compudoc processes plain text sources files by breaking the file into "chunks" of document text and python code. For example,
  a document with the text

  ```
  Some text
  % {{{
  % import os
  % }}}
  Some more text
  % {{{
  % CWD = os.getcwd()
  % }}}
  The current directory is {{ CWD }}.

  ```
  would be split into 5 chunks. The first chunk is the document text 'Some text\n', the second chunk is python code and so on.




  Python code is embedded in your document's comments. Code blocks within comment blocks
  are marked with a '{{{' and '}}}' line. Here is a LaTeX example.



  ```latex
  % arara: pdflatex

  % start with vim --server latex %
  \documentclass[]{article}

  \usepackage{siunitx}
  \usepackage{physics}
  \usepackage{graphicx}
  \usepackage{fullpage}

  \author{C.D. Clark III}
  \title{On...}
  \begin{document}
  \maketitle

  % {{{ {}
  % import pint
  % ureg = pint.UnitRegistry()
  % Q_ = ureg.Quantity
  % }}}

  Laser exposures are characterized by a power ($\Phi$), energy ($Q$), radiant exposure ($H$),
  or irradiance ($E$). Each of these four radiometric quantities are related to each other
  through the exposure area and duration.

  % {{{ {}
  % power = Q_(100,'mW')
  % duration = Q_(0.25,'s')
  % energy = (power * duration).to("mJ")
  % }}}

  For example, if a laser outputs a power of {{'{:Lx}'.format(power)}} for a
  duration of {{duration | fmt("Lx")}}, then the energy delivered during the
  exposure will be {{energy | fmt("Lx")}}.

  \end{document}

  ```
  Save this to a file named `main.tex` and run
  ```bash
  $ compudoc main.tex
  ```
  This will create a file named `main-rendered.tex` with the following content

  ```latex
  % arara: pdflatex

  % start with vim --server latex %
  \documentclass[]{article}

  \usepackage{siunitx}
  \usepackage{physics}
  \usepackage{graphicx}
  \usepackage{fullpage}

  \author{C.D. Clark III}
  \title{On...}
  \begin{document}
  \maketitle

  % {{{ {}
  % import pint
  % ureg = pint.UnitRegistry()
  % Q_ = ureg.Quantity
  % }}}

  Laser exposures are characterized by a power ($\Phi$), energy ($Q$), radiant exposure ($H$),
  or irradiance ($E$). Each of these four radiometric quantities are related to each other
  through the exposure area and duration.

  % {{{ {}
  % power = Q_(100,'mW')
  % duration = Q_(0.25,'s')
  % energy = (power * duration).to("mJ")
  % }}}

  For example, if a laser outputs a power of \SI[]{100}{\milli\watt} for a
  duration of \SI[]{0.25}{\second}, then the energy delivered during the
  exposure will be \SI[]{25.0}{\milli\joule}.

  \end{document}

  ```


pkgId: 4c0af512fc452ab513e05247bf8b531f5ec6c563c7dcb85991a919832caa131b
name: python-computation-graph-help
arch: noarch
version: 62
epoch: 0
release: 1
summary: Development documents and examples for computation-graph
url: https://pypi.org/project/computation-graph/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-computation-graph-62-1.src.rpm
location_href: Packages/python-computation-graph-help-62-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/hyroai/computation-graph.svg?branch=master)](https://travis-ci.com/hyroai/computation-graph)

  A function composition framework that supports:

  1. State - functions which retain state for their next turn of action.
  2. Prioritized paths - lazily attempt overloaded composition paths according to priorities.
  3. Deep dependency injection - compose a function to a variadic function at the end of an arbitrarily long pipeline.
  4. Non cancerous `asyncio` support.

  `pip install computation-graph`

  To deploy: `python setup.py sdist bdist_wheel; twine upload dist/*; rm -rf dist/;`



  The runner will type check all outputs for nodes with return type annotations. In case of a wrong typing, it will log the node at fault.





  Available computation trace visualizers:

  1. `graphviz.computation_trace`
  1. `mermaid.computation_trace`
  1. `ascii.computation_trace`

  To use, replace `to_callable` with `run.to_callable_with_side_effect` with your selected style as the first argument.



  This debugger will save a file on each graph execution to current working directory.

  You can use this file in a graph viewer like [gephi](https://gephi.org/).
  Nodes colored red are part of the 'winning' computation path.
  Each of these nodes has the attributes 'result' and 'state'.
  'result' is the output of the node, and 'state' is the _new_ state of the node.

  In gephi you can filter for the nodes participating in calculation of final result by filtering on result != null.


pkgId: 26cbf3a1700112d61984497cda699d039e4678d2ddfbb533804a963602bc3c11
name: python-computenest-cli-help
arch: noarch
version: 1.9.3
epoch: 0
release: 1
summary: Development documents and examples for computenest-cli
url: https://computenest.console.aliyun.com/welcome
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-computenest-cli-1.9.3-1.src.rpm
location_href: Packages/python-computenest-cli-help-1.9.3-1.noarch.rpm
checksum_type: sha256
description:
  `computenest-cli` is a command-line tool that integrates the creation, updating, and deployment of artifacts, as well as
  the creation and updating of services within the ComputeNest framework. It allows users to manage their services,
  construct artifacts, and handle custom operations, such as custom image creation.

  Documentation for operations can be found in the Project Links or [computenest-cli-docs](https://github.com/aliyun-computenest/computenest-cli-docs).


pkgId: 20a5a0e8a337fa4c55191eb7b947482077982b7b55f69dc40d9386a098b8d1c3
name: python-conan-help
arch: noarch
version: 2.10.3
epoch: 0
release: 1
summary: Development documents and examples for conan
url: https://conan.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conan-2.10.3-1.src.rpm
location_href: Packages/python-conan-help-2.10.3-1.noarch.rpm
checksum_type: sha256
description:
  Ran 146 tests in 50.993s
  OK
  ```
  To run specific tests, you can specify the test name too, something like:
  ```bash
  $ python -m pytest test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
  ```
  The `-s` argument can be useful to see some output that otherwise is captured by *pytest*.
  Also, you can run tests against an instance of Artifactory. Those tests should add the attribute
  `artifactory_ready`.
  ```bash
  $ python -m pytest . -m artifactory_ready
  ```
  Some environment variables have to be defined to run them. For example, for an
  Artifactory instance that is running on the localhost with default user and password configured, the
  variables could take the values:
  ```bash
  $ export CONAN_TEST_WITH_ARTIFACTORY=1
  $ export ARTIFACTORY_DEFAULT_URL=http://localhost:8081/artifactory
  $ export ARTIFACTORY_DEFAULT_USER=admin
  $ export ARTIFACTORY_DEFAULT_PASSWORD=password
  ```
  `ARTIFACTORY_DEFAULT_URL` is the base URL for the Artifactory repo, not one for a specific
  repository. Running the tests with a real Artifactory instance will create repos on the fly so please
  use a separate server for testing purposes.

  [MIT LICENSE](LICENSE.md)


pkgId: 85bb45011ac652a2ff1256741542b7e666782a5545c49fb6e9c8986af0271984
name: python-condensetech.cdk-constructs-help
arch: noarch
version: 0.5.7
epoch: 0
release: 1
summary: Development documents and examples for condensetech.cdk-constructs
url: https://github.com/cdklabs/cdk-monitoring-constructs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-condensetech.cdk-constructs-0.5.7-1.src.rpm
location_href: Packages/python-condensetech.cdk-constructs-help-0.5.7-1.noarch.rpm
checksum_type: sha256
description:
  This library contains constructs and stacks we use across our projects.



  <details>
    <summary>Node.js</summary>
    Install the package:

  ```bash
  npm install @condensetech/cdk-constructs # or
  yarn add @condensetech/cdk-constructs # or
  pnpm add @condensetech/cdk-constructs
  ```

  Import it:

  ```python
  import * as condense from '@condensetech/cdk-constructs';
  ```

  </details>
  <details>
    <summary>Python</summary>
    Install the package:

  ```bash
  pip install condensetech.cdk-constructs
  ```

  Import it:

  ```py
  from condensetech import cdk_constructs
  ```

  </details>
  <details>
    <summary>.NET</summary>
    Install the package:

  ```bash
  dotnet add package CondenseTech.CdkConstructs
  ```

  Import it:

  ```csharp
  using CondenseTech.CdkConstructs;
  ```

  </details>
  <details>
    <summary>Go</summary>
    Install the package:

  ```bash
  go get github.com/condensetech/cdk-constructs
  ```

  Import it:

  ```go
  import "github.com/condensetech/cdk-constructs"
  ```

  </details>



  All API docs can be found in the [API.md](./API.md).



  Readability and maintainability are key factors when writing IaC. By defining some high level interfaces, we can easily write constructs which don't need to be tied to the specific implementation of a resource.

  For example, the [INetworking](lib/interfaces.ts), defines some high level methods to interact with a VPC. Often a VPC contains a bastion host, which should be whitelisted to databases, so the interface has a `bastionHost` property which can return the bastion host. This allows to write code like the following:

  ```python
  interface MyDatabaseStackProps extends cdk.StackProps {
    networking: INetworking;
  }
  class MyDatabaseStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: MyDatabaseStackProps) {
      super(scope, id, props);

      const db = new rds.DatabaseInstance(this, 'Database', {
        vpc: props.networking.vpc,
        ...
      });
      if (props.networking.bastionHost) {
        db.connections.allowDefaultPortFrom(props.networking.bastionHost);
      }
    }
  }
  ```

  If a certain point we want to add a bastion host, we just need to flip one single switch in the networking props, to have the bastion host able to connect to all the resources in the VPC.

  Constructs and Stacks in this area:

  * [Networking](lib/constructs/networking.ts) and [NetworkingStack](lib/stacks/networking.ts)
  * [Aurora Cluster](lib/constructs/aurora-cluster.ts) and [AuroraClusterStack](lib/stacks/aurora-cluster.ts)
  * [RDS Instance](lib/constructs/database-instance.ts) and [DatabaseInstanceStack](lib/stacks/database-instance.ts)



  A typical scenario is to have one single Application Load Balancer in a VPC, which routes traffic to different services. The [Entrypoint Construct](lib/constructs/entrypoint.ts) and the [Entrypoint Stack](lib/stacks/entrypoint-stack.ts) allow to easily define this entrypoint load balancer.

  The [Entrypoint#allocateListenerRule](API.md#@condensetech/cdk-constructs.Entrypoint.allocateListenerRule) method tracks in a DynamoDB table the priority of the listener rules that are being created and generates a unique priority if one is not provided. This allows to operate in scenarios where different stacks are creating listener rules for the same load balancer.



  The [CloudwatchAlarmsTopicStack](lib/stacks/cloudwatch-alarms-topic-stack.ts) creates an SNS Topic which can be used as a target for Cloudwatch Alarms. In addition to link the topic to HTTPS endpoints, it can also create a Lambda function which can be used to send messages to Discord or Slack.



  [NaiveBasicAuthCloudfrontFunction](lib/constructs/naive-basic-auth-cloudfront-function.ts) is useful when a basic protection layer must be added to Cloudfront (for SPAs or static sites) and you just need to avoid crawlers and unwanted visitors.



  By instantiating a [MonitoringFacade](lib/constructs/monitoring/monitoring-facade.ts) in your stack, you can easily add monitoring to your resources. The facade will create a Cloudwatch Dashboard, and will add alarms to the resources you want to monitor.


pkgId: 0a1f5b3de8aeb02e8a763f5db5cc578071470047032589d17fa42af79da52082
name: python-conditional-drawdown-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for conditional-drawdown
url: https://github.com/internQuant/conditional-drawdown
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conditional-drawdown-0.1.1-1.src.rpm
location_href: Packages/python-conditional-drawdown-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  `conditional-drawdown` is a Python library designed for advanced drawdown risk analysis, with a focus on the Conditional Expected Drawdown (CED) metric. Unlike traditional risk metrics like volatility or Value-at-Risk, CED accounts for the path dependency of drawdowns and provides a robust measure of extreme risk. This tool is ideal for portfolio managers, risk analysts, and quantitative researchers.

  Key features include:

  - **Maximum Drawdown (MDD):** Calculates the largest cumulative loss from peak to trough over a given time period.
  - **Rolling Maximum Drawdown (RMD):** Computes drawdowns over sliding windows to track evolving risks.
  - **Conditional Expected Drawdown (CED):** Estimates the expected maximum drawdown given that a threshold is breached, enabling deeper insights into tail risk.
  - **Portfolio Risk Attribution:(WIP)** Analyze and attribute risk contributions across assets or factors using CED.



  You can install the library via pip:

  ```bash
  pip install conditional-drawdown
  ```


  ```python
  from conditional_drawdown import CED, max_drawdown, rolling_max_drawdown
  import yfinance as yf


  tickers = ["ES=F", "GLD"]
  data = yf.download(tickers, end="2023-12-31")["Adj Close"]


  returns = data.pct_change().dropna()


  es_ced = CED(returns['ES=F'].values)
  gld_ced = CED(returns['GLD'].values)

  print(f"S&P Futures CED: {es_ced}")
  print(f"Gold ETF CED: {gld_ced}")


  portfolio_returns = (returns * 0.5).sum(axis=1)
  portfolio_ced = CED(portfolio_returns.values)
  print(f"Portfolio CED: {portfolio_ced}")
  ```


  - Maximum Drawdown (MDD):
  Calculates the largest cumulative loss from peak to trough in a return series.
  Example:
  ```py
      max_dd = max_drawdown(returns['ES=F'].values)
      print(f"Max Drawdown: {max_dd}")
  ```

  - Rolling Maximum Drawdown (RMD):

  Computes MDD over rolling windows, enabling time-sensitive risk tracking.
  Example:
  ```py
      rmd = rolling_max_drawdown(returns['GLD'].values, window=21)
      print(f"Rolling Max Drawdown: {rmd}")
  ```
  - Conditional Expected Drawdown (CED):

  Focuses on the tail-end of drawdown distributions, providing a measure of extreme risk exposure.
  Example:
  ```py
          ced = CED(returns['GLD'].values, t=21, alpha=0.9)
          print(f"Conditional Expected Drawdown: {ced}")
  ```


  - Path Dependency: CED captures consecutive losses, unlike volatility or Value-at-Risk.
  - Convex and Linear: Useful for portfolio optimization and risk attribution.
  - Tail Risk Sensitivity: Ideal for stress-testing portfolios under extreme market conditions.



  Contributions are welcome! Please follow these steps:

  - Fork the repository.
  - Create a feature branch: git checkout -b feat/feature-name
  - Commit your changes: git commit -m 'Add new feature'
  - Push to your branch: git push origin feature-name
  - Open a pull request.



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



  Inspired by the work of Lisa R. Goldberg and Ola Mahmoud, Drawdown: From Practice to Theory and Back Again.
  arXiv:1404.7493


pkgId: 531bd5f198387813304ccf7b461cf5d60a7c3e06090d9865ee3b3f5bb9de299c
name: python-conductorquantum-help
arch: noarch
version: 0.0.19
epoch: 0
release: 1
summary: Development documents and examples for conductorquantum
url: https://pypi.org/project/conductorquantum/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conductorquantum-0.0.19-1.src.rpm
location_href: Packages/python-conductorquantum-help-0.0.19-1.noarch.rpm
checksum_type: sha256
description:
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2Fconductorquantum%2Fconductorquantum-python)
  [![pypi](https://img.shields.io/pypi/v/conductorquantum)](https://pypi.python.org/pypi/conductorquantum)

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



  ```sh
  pip install conductorquantum
  ```



  A full reference for this library is available [here](./reference.md).



  Instantiate and use the client with the following:

  ```python
  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      token="YOUR_TOKEN",
  )

  with open("path/to/file.npy", "rb") as f:
      client.models.execute(
          model="coulomb-blockade-peak-detector",
          file=f,
      )
  ```



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

  ```python
  import asyncio

  from conductorquantum import AsyncConductorQuantum

  client = AsyncConductorQuantum(
      token="YOUR_TOKEN",
  )


  async def main() -> None:
      with open("path/to/file.npy", "rb") as f:
          await client.models.execute(
              model="coulomb-blockade-peak-detector",
              file=f,
          )


  asyncio.run(main())
  ```



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

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

  try:
      client.models.execute_with_file(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```





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

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

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

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

  ```python
  client.models.execute_with_file(..., request_options={
      "max_retries": 1
  })
  ```



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

  ```python

  from conductorquantum import ConductorQuantum

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



  client.models.execute_with_file(..., request_options={
      "timeout_in_seconds": 1
  })
  ```



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

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



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

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


pkgId: 3a1b7d5bfb08d9aa6f816d23b3752c58b99431aa5759cc0b7714a78b73bb4bfc
name: python-conette-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for conette
url: https://pypi.org/project/conette/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conette-0.3.2-1.src.rpm
location_href: Packages/python-conette-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  [![](<https://img.shields.io/badge/-Python 3.10+-blue?style=for-the-badge&logo=python&logoColor=white>)](https://www.python.org/)
  [![](<https://img.shields.io/badge/-PyTorch 1.10.1+-ee4c2c?style=for-the-badge&logo=pytorch&logoColor=white>)](https://pytorch.org/get-started/locally/)
  [![](https://img.shields.io/badge/code%20style-black-black.svg?style=for-the-badge&labelColor=gray)](https://black.readthedocs.io/en/stable/)
  [![](https://img.shields.io/github/actions/workflow/status/Labbeti/conette-audio-captioning/inference.yaml?branch=main&style=for-the-badge&logo=github)](https://github.com/Labbeti/conette-audio-captioning/actions)

  </div>

  CoNeTTE is an audio captioning system, which generate a short textual description of the sound events in any audio file. The architecture and training are explained in the [corresponding paper on IEEE](https://ieeexplore.ieee.org/document/10603439) (you can also find an older pre-print version on [arXiv here](https://arxiv.org/pdf/2309.00454.pdf)). The model has been developped by me ([Étienne Labbé](https://labbeti.github.io/) :) ) during my PhD. A simple interface to test CoNeTTE is available on the [HuggingFace website](https://huggingface.co/spaces/Labbeti/conette).



  - Intended for Ubuntu 20.04 only. Requires **java** < 1.13, **ffmpeg**, **yt-dlp**, and **zip** commands.
  - Recommanded GPU: NVIDIA V100 with 32GB VRAM.
  - WavCaps dataset might requires more than 2 TB of disk storage. Other datasets requires less than 50 GB.


  By default, **only the pip inference requirements are installed for conette**. To install training requirements you need to use the following command:
  ```bash
  python -m pip install conette[train]
  ```
  If you already installed conette for inference, it is **highly recommanded to create another environment** before installing conette for training.


  These steps might take a while (few hours to download and prepare everything depending on your CPU, GPU and SSD/HDD).

  First, download the ConvNeXt, NLTK and spacy models :
  ```bash
  conette-prepare data=none default=true pack_to_hdf=false csum_in_hdf_name=false pann=false
  ```

  Then download the 4 datasets used to train CoNeTTE :
  ```bash
  common_args="data.download=true pack_to_hdf=true audio_t=resample_mean_convnext audio_t.pretrain_path=cnext_bl_75 post_hdf_name=bl pretag=cnext_bl_75"

  conette-prepare data=audiocaps audio_t.src_sr=32000 ${common_args}
  conette-prepare data=clotho audio_t.src_sr=44100 ${common_args}
  conette-prepare data=macs audio_t.src_sr=48000 ${common_args}
  conette-prepare data=wavcaps audio_t.src_sr=32000 ${common_args} datafilter.min_audio_size=0.1 datafilter.max_audio_size=30.0 datafilter.sr=32000
  ```


  CNext-trans (baseline) on CL only (~3 hours on 1 GPU V100-32G)
  ```bash
  conette-train expt=[clotho_cnext_bl] pl=baseline
  ```

  CoNeTTE on AC+CL+MA+WC, specialized for CL (~4 hours on 1 GPU V100-32G)
  ```bash
  conette-train expt=[camw_cnext_bl_for_c,task_ds_src_camw] pl=conette
  ```

  CoNeTTE on AC+CL+MA+WC, specialized for AC (~3 hours on 1 GPU V100-32G)
  ```bash
  conette-train expt=[camw_cnext_bl_for_a,task_ds_src_camw] pl=conette
  ```

  Note 1: any training using AC data cannot be exactly reproduced because a part of this data is deleted from the YouTube source, and I cannot share my own audio files.
  Note 2: paper results are averaged scores over 5 seeds (1234-1238). The default training only uses seed 1234.




  ```bash
  python -m pip install conette[test]
  ```


  Simply use the command `conette-predict` with `--audio PATH1 PATH2 ...` option. You can also export results to a CSV file using `--csv_export PATH`.

  ```bash
  conette-predict --audio "/your/path/to/audio.wav"
  ```


  ```py
  from conette import CoNeTTEConfig, CoNeTTEModel

  config = CoNeTTEConfig.from_pretrained("Labbeti/conette")
  model = CoNeTTEModel.from_pretrained("Labbeti/conette", config=config)

  path = "/your/path/to/audio.wav"
  outputs = model(path)
  candidate = outputs["cands"][0]
  print(candidate)
  ```

  The model can also accept several audio files at the same time (list[str]), or a list of pre-loaded audio files (list[Tensor]). In this second case you also need to provide the sampling rate of this files:

  ```py
  import torchaudio

  path_1 = "/your/path/to/audio_1.wav"
  path_2 = "/your/path/to/audio_2.wav"

  audio_1, sr_1 = torchaudio.load(path_1)
  audio_2, sr_2 = torchaudio.load(path_2)

  outputs = model([audio_1, audio_2], sr=[sr_1, sr_2])
  candidates = outputs["cands"]
  print(candidates)
  ```

  The model can also produces different captions using a Task Embedding input which indicates the dataset caption style. The default task is "clotho".

  ```py
  outputs = model(path, task="clotho")
  candidate = outputs["cands"][0]
  print(candidate)

  outputs = model(path, task="audiocaps")
  candidate = outputs["cands"][0]
  print(candidate)
  ```


  The model has been trained on AudioCaps (AC), Clotho (CL), MACS (MA) and WavCaps (WC). The performance on the test subsets are :

  | Test data | SPIDEr (%) | SPIDEr-FL (%) | FENSE (%) | Vocab | Outputs | Scores |
  | ------------- | ------------- | ------------- | ------------- | ------------- | ------------- | ------------- |
  | AC-test | 44.14 | 43.98 | 60.81 | 309 | [Link](https://github.com/Labbeti/conette-audio-captioning/blob/main/results/detailed_outputs/outputs_audiocaps_test.csv) | [Link](https://github.com/Labbeti/conette-audio-captioning/blob/main/results/detailed_outputs/scores_audiocaps_test.yaml) |
  | CL-eval | 30.97 | 30.87 | 51.72 | 636 | [Link](https://github.com/Labbeti/conette-audio-captioning/blob/main/results/detailed_outputs/outputs_clotho_eval.csv) | [Link](https://github.com/Labbeti/conette-audio-captioning/blob/main/results/detailed_outputs/scores_clotho_eval.yaml) |

  This model checkpoint has been trained with focus on the Clotho dataset, but it can also reach a good performance on AudioCaps with the "audiocaps" task.


  - The model expected audio sampled at **32 kHz**. The model automatically resample up or down the input audio files. However, it might give worse results, especially when using audio with lower sampling rates.
  - The model has been trained on audio lasting from **1 to 30 seconds**. It can handle longer audio files, but it might require more memory and give worse results.


  The final version of the paper describing CoNeTTE is available on IEEExplore: https://ieeexplore.ieee.org/document/10603439. A preprint version of the paper is also available on arXiv: https://arxiv.org/pdf/2309.00454.pdf.

  **Final version recommanded for citation (IEEE):**
  ```bibtex
  @article{labbe2023conetteieee,
  	title        = {CoNeTTE: An Efficient Audio Captioning System Leveraging Multiple Datasets With Task Embedding},
  	author       = {Labbé, Étienne and Pellegrini, Thomas and Pinquier, Julien},
  	year         = 2024,
  	journal      = {IEEE/ACM Transactions on Audio, Speech, and Language Processing},
  	volume       = 32,
  	number       = {},
  	pages        = {3785--3794},
  	doi          = {10.1109/TASLP.2024.3430813},
  	url          = {https://ieeexplore.ieee.org/document/10603439},
  	keywords     = {Decoding;Task analysis;Transformers;Training;Convolutional neural networks;Speech processing;Tagging;Audio-language task;automated audio captioning;dataset biases;task embedding;deep learning}
  }
  ```

  **Preprint version (arXiv):**
  ```bibtex
  @misc{labbe2023conettearxiv,
  	title        = {CoNeTTE: An efficient Audio Captioning system leveraging multiple datasets with Task Embedding},
  	author       = {Étienne Labbé and Thomas Pellegrini and Julien Pinquier},
  	year         = 2023,
  	journal      = {arXiv preprint arXiv:2309.00454},
  	url          = {https://arxiv.org/pdf/2309.00454.pdf},
  	eprint       = {2309.00454},
  	archiveprefix = {arXiv},
  	primaryclass = {cs.SD}
  }
  ```


  - CoNeTTE stands for **Co**nv**Ne**Xt-**T**ransformer with **T**ask **E**mbedding.
  - Raw model weights are available on HuggingFace: https://huggingface.co/Labbeti/conette
  - The weights of the encoder part of the architecture is based on a ConvNeXt model for audio classification, available here: https://zenodo.org/records/10987498 under the filename "convnext_tiny_465mAP_BL_AC_75kit.pth".


  Maintainer:
  - [Étienne Labbé](https://labbeti.github.io/) "Labbeti": labbeti.pub@gmail.com

rpm_license:
  MIT License  Copyright (c) 2024 Labbeti  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: fa60801de45afc429af753107d7418c6d7bdbad96cebdf94601aa46bf4bbd05e
name: python-config-ninja-help
arch: noarch
version: 1.6.1
epoch: 0
release: 1
summary: Development documents and examples for config-ninja
url: https://config-ninja.github.io/config-ninja/config_ninja.html
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-config-ninja-1.6.1-1.src.rpm
location_href: Packages/python-config-ninja-help-1.6.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![🎨 poe (push)](https://github.com/config-ninja/config-ninja/actions/workflows/push-poe.yaml/badge.svg)](https://github.com/config-ninja/config-ninja/actions/workflows/push-poe.yaml)
  [![pylint](https://config-ninja.github.io/config-ninja/reports/pylint.svg)](https://config-ninja.github.io/config-ninja/reports/pylint-report.txt)
  [![codecov](https://codecov.io/gh/config-ninja/config-ninja/graph/badge.svg?token=R3DFDSNK9U)](https://codecov.io/gh/config-ninja/config-ninja)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/config-ninja/config-ninja/main.svg)](https://results.pre-commit.ci/latest/github/config-ninja/config-ninja/main)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://config-ninja.github.io/config-ninja/reports/mypy-html)
  [![docs: pdoc](https://img.shields.io/badge/docs-pdoc-blueviolet?logo=github)](https://config-ninja.github.io/config-ninja/config_ninja.html)
  [![readthedocs](https://readthedocs.org/projects/config-ninja/badge/?version=latest)](https://config-ninja.readthedocs.io/en/latest/home.html)
  [![PyPI version](https://badge.fury.io/py/config-ninja.svg)](https://badge.fury.io/py/config-ninja)
  [![Downloads](https://static.pepy.tech/badge/config-ninja/month)](https://pepy.tech/project/config-ninja)

  Similar to [`confd`](https://github.com/kelseyhightower/confd), manage your system configuration files by populating [Jinja2](https://jinja.palletsprojects.com/en/3.1.x/) templates with data from a remote provider.

  The `config-ninja` agent monitors the backend source for changes. When the source data is changed, the agent updates the local configuration file with the new data:

  ```mermaid
  sequenceDiagram
  		loop polling
  			 config-ninja->>backend: query for changes
  		end

  		backend->>+config-ninja: [backend changed] fetch config
  		config-ninja->>-filesystem: write updated configuration file
  ```



  - ✅ Integration with [AWS AppConfig](https://jinja.palletsprojects.com/en/3.1.x/) for managing server configuration files
  - ✅ Extensible design supports backends for new providers and formats
  - ✅ [`jinja2`](https://jinja.palletsprojects.com/en/3.1.x/) templating for arbitrary configuration file formats
  - ✅ Execute [`poethepoet`](https://poethepoet.natn.io/index.html) tasks after updating files



  `config-ninja` is installed using the official installer or with `pip` / `pipx`. After installation, you can enable `config-ninja` as a `systemd` service.



  The recommended way to install `config-ninja` is with the official installer:

  ```sh
  curl -sSL https://config-ninja.github.io/config-ninja/install.py | python3 -
  ```

  To view available installation options, run the installer with the `--help` flag:

  ```sh
  curl -sSL https://config-ninja.github.io/config-ninja/install.py | python3 - --help
  ```

  ```
  usage: install [-h] [--version VERSION] [--pre] [--uninstall] [--force] [--path PATH] [--backends BACKENDS]

  Installs the latest (or given) version of config-ninja

  options:
  	-h, --help           show this help message and exit
  	--version VERSION    install named version
  	--pre                allow pre-release versions to be installed
  	--uninstall          uninstall config-ninja
  	--force              respond 'yes' to confirmation prompts; overwrite existing installations
  	--path PATH          install config-ninja to this directory
  	--backends BACKENDS  comma-separated list of package extras to install, or 'none' to install no backends
  ```



  Alternatively, use `pip` / `pipx` to install [all available backends](https://config-ninja.github.io/config-ninja/config_ninja/contrib.html#available-backends) (or choose a specific one):

  ```sh
  pipx install 'config-ninja[all]'
  ```



  ```sh
  uv tool install 'config-ninja[all]'
  ```



  After installing `config-ninja`, enable it as a `systemd` service for the current user:

  ```sh

  config-ninja self install --user
  ```



  To demonstrate how the mechanics work (using the [local backend](https://config-ninja.readthedocs.io/en/latest/config_ninja/contrib/local.html)):

  1. create a settings file for `config-ninja`:
     ```sh
     cat <<EOF >config-ninja-settings.yaml
     CONFIG_NINJA_OBJECTS:
     	 example-0:
     		 dest:
     			 format: json
     			 path: ./.local/settings.json
     		 source:
     			 backend: local
     			 format: toml
     			 init:
     				 kwargs:
     					 path: ./.local/config.toml
     EOF
     ```
  2. run `config-ninja` in monitor mode:
     ```sh
     config-ninja apply --poll
     ```
  3. in a separate shell, create the `config.toml`:
     ```sh
     cat <<EOF >./.local/config.toml
     [example-0]
     a = "first value"
     b = "second value
     EOF
     ```
  4. Inspect the `settings.json` file created by `config-ninja`:
     ```sh
     cat ./.local/settings.json
     ```
     ```json
     {
       "example-0": {
         "a": "first value",
         "b": "second value"
       }
     }
     ```
  5. Make changes to the data in `config.toml`, and `config-ninja` will update `settings.json` accordingly:
     ```sh
     cat <<EOF >>./.local/config.toml
     [example-1]
     c = "third value"
     d = "fourth value
     EOF
     cat ./.local/settings.json
     ```
     ```json
     {
       "example-0": {
         "a": "first value",
         "b": "second value"
       },
       "example-1": {
         "c": "third value",
         "d": "fourth value"
       }
     }
     ```
     Chances are, you'll want to update the `config-ninja-settings.yaml` file to use a remote backend (instead of `local`). See [config_ninja.contrib](https://config-ninja.github.io/config-ninja/config_ninja/contrib.html) for a list of supported config providers.


