# packages

pkgId: c3b27d9d11273f3a8feb631379ab02e1df1478bce5e1e0dc1c4905e95a2688d4
name: python-chalice-spec
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Chalice x APISpec x Pydantic plug-ins
url: https://github.com/TestBoxLab/chalice-spec
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chalice-spec-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/TestBoxLab/chalice-spec/actions/workflows/test.yml/badge.svg)](https://github.com/TestBoxLab/chalice-spec/actions/workflows/test.yml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  **Chalice × APISpec × Pydantic plug-ins**

  Combines the power of Chalice, APISpec, and Pydantic to make AWS Chalice apps easily documented



  First, add chalice-spec:

  ```shell
  poetry add chalice_spec
  ```

  We consider Chalice, APISpec, and Pydantic "peer dependencies." We only include them as dev
  dependencies in our codebase, and you may need to install them in yours if you haven't
  already.

  ```shell
  poetry add chalice apispec pydantic
  ```



  chalice-spec provides a subclass of the main `Chalice` class, called `ChaliceWithSpec`.
  Here is an example of how to get started:

  Before:

  ```python
  from chalice import Chalice

  app = Chalice(app_name="hello_world")
  ```

  After:

  ```python
  from chalice_spec import ChaliceWithSpec, PydanticPlugin
  from apispec import APISpec

  spec = APISpec(...,
                 plugins=[PydanticPlugin()])

  app = ChaliceWithSpec(app_name="hello_world", spec=spec)
  ```

  If you use

  ```python
  ChaliceWithSpec(..., generate_default_docs=True)
  ```

  the plugin will generate empty docs (with empty request and response schemas) for every endpoint that you've defined in your app. This can be useful as a starting point / overview while developing.



  To document your API, use your existing Pydantic models and add kwargs to Chalice decorators.

  **Before:**
  ```python
  @app.route('/', methods=["POST"])
  def example():
      body = MySchema.parse_obj(app.current_request.json_body)
  ```

  **After:**
  ```python
  @app.route('/', methods=["POST"], docs=Docs(
      post=Operation(request=MySchema)
  ))
  def example():
      body = MySchema.parse_obj(app.current_request.json_body)
  ```

  If you have multiple methods supported, you may have something like:

  ```python
  @app.route('/', methods=["POST", "PUT"],
             docs=Docs(
                 post=Operation(request=MyCreateSchema, response=MyReadSchema),
                 put=Operation(request=MyEditSchema, response=MyReadSchema)
             )
  def example():
      
      pass
  ```





  If you use:
  ```python
  ChalicePlugin(generate_default_docs=True)
  ```
  the plugin will generate empty docs (with empty request and response schemas) for every endpoint that you've defined in your app. This can be useful as a starting point / overview while developing.



  These are inferred from the path itself. Any identifiers inside curly braces in a path is added as a string path parameter for that path. e.g. for the path `/users/{id}/friends/{f_id}`, the path parameters `id` and `f_id` will be added to the spec.

  To disable this behaviour, define your own parameters or set them to an empty list:

  ```python
  Operation(request=MySchema, response=MyOtherSchema, parameters=[])
  ```



  Tags are used in things like Swagger to group endpoints into logical sets. If you don't supply any tags, chalice-spec will add a tag for each endpoint that is the first segment of the path. e.g. `/users`, `/users/{id}/friends`, and `/users/{id}/posts` will all be tagged with `users`.

  To disable this behaviour, define `tags` in your operation (either with the tags you want, or an empty list):

  ```python
  Operation(request=MySchema, response=MyOtherSchema, tags=[])
  ```



  Endpoint summaries and descriptions are inferred from the route docstring. The first line of the docstring is used as the summary, and all other lines become the description:

  ```python
  @app.route('/users/{id}', methods=['GET'], docs=Docs(response=UserSchema))
  def get_user(id):
      """
      Retrieve a user object.
      User's can't retrieve other users using this endpoint - only themselves.
      """
  ```

  To disable this behaviour, you can define your own summary/description or set them to empty strings:

  ```python
  Operation(request=MySchema, response=MyOtherSchema, summary='', description='')
  ```




  - [ ] TODO: this section coming soon!


pkgId: ed5c3ca1f4c3f00d87f60a90e0e2f569ce3ab6281162611c118b1a6e9e862833
name: python-chalkpy
arch: src
version: 2.59.0
epoch: 0
release: 1
summary: Python SDK for Chalk
url: https://chalk.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chalkpy-2.59.0-1.src.rpm
checksum_type: sha256
description:
  Chalk makes it simple to develop feature pipelines for machine
  learning. Define Python functions using the libraries and tools you're
  familiar with instead of specialized DSLs. Chalk then orchestrates
  your functions into pipelines that execute in parallel on a Rust-based
  engine and coordinates the infrastructure required to compute
  features.

  To get started, [define your features](/docs/features) with
  [Pydantic](https://pydantic-docs.helpmanual.io/)-inspired Python classes.
  You can define schemas, specify relationships, and add metadata
  to help your team share and re-use work.
  ```py
  @features
  class User:
      id: int
      full_name: str
      nickname: Optional[str]
      email: Optional[str]
      birthday: date
      credit_score: float
      datawarehouse_feature: float
      transactions: DataFrame[Transaction] = has_many(lambda: Transaction.user_id == User.id)
  ```

  Next, tell Chalk how to compute your features.
  Chalk ingests data from your existing data stores,
  and lets you use Python to compute features with
  [feature resolvers](/docs/resolver-overview).
  Feature resolvers are declared with the decorators `@online` and
  `@offline`, and can depend on the outputs of other feature resolvers.
  Resolvers make it easy to rapidly integrate a wide variety of data
  sources, join them together, and use them in your model.

  ```python
  pg = PostgreSQLSource()
  @online
  def get_user(uid: User.id) -> Features[User.full_name, User.email]:
      return pg.query_string(
          "select email, full_name from users where id=:id",
          args=dict(id=uid)
      ).one()
  ```

  ```python
  import requests
  @online
  def get_socure_score(uid: User.id) -> Features[User.socure_score]:
      return (
          requests.get("https://api.socure.com", json={
              id: uid
          }).json()['socure_score']
      )


pkgId: 84bb0d8f96b4156241e3b1a393a36e4a37c28bf0bdb334f6a7043cb5d60f8712
name: python-chameleon.core
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Attribute language template compiler
url: UNKNOWN
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chameleon.core-1.0.4-1.src.rpm
checksum_type: sha256
description:
  .. important:: This package has been retired; use the Chameleon_ package instead.

  .. _Chameleon: http://pypi.python.org/pypi/Chameleon


pkgId: 92c384b6013a3a4540cffd5dff1d1f0a30f5fe721ddcd255febfdd3b2cf6f11d
name: python-chameleon_flask
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Adds integration of the Chameleon template language to Flask and Quart.
url: https://github.com/mikeckennedy/chameleon-flask
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chameleon_flask-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Adds integration of the Chameleon template language to Flask and Quart.



  Simply `pip install chameleon_flask`.



  This is easy to use. Just create a folder within your web app to hold the templates such as:

  ```
  ├── app.py
  ├── views.py
  │
  ├── templates
  │   ├── home
  │   │   └── index.pt
  │   └── shared
  │       └── layout.pt

  ```

  In the app startup, tell the library about the folder you wish to use:

  ```python
  import os
  from pathlib import Path
  import chameleon_flask

  dev_mode = True

  BASE_DIR = Path(__file__).resolve().parent
  template_folder = str(BASE_DIR / 'templates')
  chameleon_flask.global_init(template_folder, auto_reload=dev_mode)
  ```

  Then just decorate the Flask or Quart view methods (works on sync and async methods):

  ```python
  @app.get('/async')
  @chameleon_flask.template('async.pt')
  async def async_world():
      await asyncio.sleep(.01)
      return {'message': "Let's go async Chameleon!"}
  ```

  The view method should return a `dict` to be passed as variables/values to the template.

  If a `flask.Response` is returned, the template is skipped and the response along with status_code and
  other values is directly passed through. This is common for redirects and error responses not meant
  for this page template. Otherwise the dictionary is used to render `async.pt` in this example.



  A common technique for user-friendly sites is to use a [custom HTML page for 404 responses](http://www.instantshift.com/2019/10/16/user-friendly-404-pages/).
  This library has support for friendly 404 pages using the `chameleon_flask.not_found()` function.

  Here's an example:

  ```python
  @app.get('/catalog/item/{item_id}')
  @chameleon_flask.template('catalog/item.pt')
  async def item(item_id: int):
      item = service.get_item_by_id(item_id)
      if not item:
          chameleon_flask.not_found()

      return item.dict()
  ```

  This will render a 404 response with using the template file `templates/errors/404.pt`.
  You can specify another template to use for the response, but it's not required.



  See the `example/example_app.py` file for a working example to play with.


pkgId: e75715c57c019256f750b8db3f236210b54fa8c6346f5cadb40a868b6ee4712f
name: python-champollion
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Sphinx extension to document javascript code.
url: http://github.com/buddly27/champollion
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-champollion-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Champollion


  .. image:: https://img.shields.io/pypi/v/champollion.svg
          :target: https://pypi.python.org/pypi/champollion

  .. image:: https://api.travis-ci.org/buddly27/champollion.svg?branch=master
      :target: https://travis-ci.org/buddly27/champollion

  .. image:: https://coveralls.io/repos/github/buddly27/champollion/badge.svg?branch=master
      :target: https://coveralls.io/github/buddly27/champollion?branch=master

  .. image:: https://readthedocs.org/projects/champollion/badge/?version=stable
          :target: http://champollion.readthedocs.io/en/stable
          :alt: Documentation Status

  Sphinx extension which provides an automatic way to document javascript code

  *************
  Documentation
  *************

  Full documentation, including installation and setup guides, can be found at
  http://champollion.readthedocs.io/en/stable/


pkgId: 688fd71418d07e72e65de67a71ee1169030d2b4ee765fbd6336724a489919ca4
name: python-chancy
arch: src
version: 0.10.9
epoch: 0
release: 1
summary: A simple and flexible job queue for Python
url: https://pypi.org/project/chancy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chancy-0.10.9-1.src.rpm
checksum_type: sha256
description:
  ![Chancy Logo](misc/logo_small.png)

  A postgres-backed task queue for Python.



  - Support for job priorities, retries, timeouts, scheduling,
    global rate limits, memory limits, and more.
  - Configurable job retention for easy debugging and tracking
  - Minimal dependencies (only psycopg3 required)
  - asyncio & sync APIs for easy integration with existing codebases
  - Plugins for a dashboard, workflows, cron jobs, and more



  Check out the getting-started guide and the API documentation at
  https://tkte.ch/chancy/.



  Many similar projects exist. Some of them are:

  - https://worker.graphile.org/ (Node.js)
  - https://riverqueue.com/ (Go)
  - https://github.com/acaloiaro/neoq (Go)
  - https://github.com/contribsys/faktory (Go)
  - https://github.com/sorentwo/oban (Elixir)
  - https://github.com/procrastinate-org/procrastinate (Python)


pkgId: 909f52eb9e5d7071ff845514b75efeb27e45ff77de67002c2ff2f5d074692200
name: python-chancy
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: A simple and flexible job queue for Python
url: https://pypi.org/project/chancy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chancy-0.13.1-1.src.rpm
checksum_type: sha256
description:
  ![Chancy Logo](misc/logo_small.png)

  A postgres-backed task queue for Python.

  ![MIT License](https://img.shields.io/github/license/tktech/chancy)
  ![Supported Version](https://img.shields.io/pypi/pyversions/chancy)




  - Support for job priorities, retries, timeouts, scheduling,
    global rate limits, memory limits, unique jobs, and more
  - asyncio-based worker with support for asyncio, threaded,
    process-based, and sub-interpreter job execution.
  - Configurable job retention for easy debugging and tracking
  - Minimal dependencies (only psycopg3 required)
  - Plugins for a dashboard, workflows, cron jobs, and more
  - Optional transactional enqueueing for atomic job creation
  - asyncio & sync APIs for easy integration with existing codebases



  Check out the getting-started guide and the API documentation at
  https://tkte.ch/chancy/.



  Chancy comes with an optional dashboard that provides a basic
  look into the status of your queues:

  ![Workflows](misc/ux_workflow.png)
  ![Queue Details](misc/ux_queue.png)
  ![Job](misc/ux_job_failed.png)



  Many similar projects exist. Some of them are:

  - https://worker.graphile.org/ (Node.js)
  - https://riverqueue.com/ (Go)
  - https://github.com/acaloiaro/neoq (Go)
  - https://github.com/contribsys/faktory (Go)
  - https://github.com/sorentwo/oban (Elixir)
  - https://github.com/procrastinate-org/procrastinate (Python)


pkgId: cf6ad92e84df7309af9aa4d2dac72e566f497fe7a0624c0034d21f0056edeaa0
name: python-chancy
arch: src
version: 0.17.0
epoch: 0
release: 1
summary: A simple and flexible job queue for Python
url: https://pypi.org/project/chancy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chancy-0.17.0-1.src.rpm
checksum_type: sha256
description:
  ![Chancy Logo](misc/logo_small.png)

  A postgres-backed task queue for Python.

  ![MIT License](https://img.shields.io/github/license/tktech/chancy)
  ![Supported Version](https://img.shields.io/pypi/pyversions/chancy)
  ![Codecov](https://img.shields.io/codecov/c/github/TkTech/chancy)
  ![PyPI Version](https://img.shields.io/pypi/v/chancy)



  - Support for job priorities, retries, timeouts, scheduling,
    global rate limits, memory limits, unique jobs, and more
  - asyncio-based worker with support for asyncio, threaded,
    process-based, and sub-interpreter job execution.
  - Configurable job retention for easy debugging and tracking
  - Minimal dependencies (only psycopg3 required)
  - Plugins for a dashboard, workflows, cron jobs, and more
  - Optional transactional enqueueing for atomic job creation
  - asyncio & sync APIs for easy integration with existing codebases



  Check out the getting-started guide and the API documentation at
  https://tkte.ch/chancy/.



  Chancy comes with an optional dashboard that provides a basic
  look into the status of your queues:

  ![Workflows](misc/ux_workflow.png)
  ![Queue Details](misc/ux_queue.png)
  ![Jobs](misc/ux_jobs.png)
  ![Job](misc/ux_job_failed.png)


pkgId: 26a8d85b056f9cc6cbeb0103e5844bb29861b6cba539b88bdda4c224b6694dbb
name: python-change-analyzer
arch: src
version: 0.16.1
epoch: 0
release: 1
summary: Change analyzer
url: https://github.com/F-Secure/change-analyzer
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-change-analyzer-0.16.1-1.src.rpm
checksum_type: sha256
description:
  - [Change analyzer](#change-analyzer)
    - [About](#about)
      - [Main Data features](#main-data-features)
      - [Data Collection](#data-collection)
      - [Data Reconstruction](#data-reconstruction)
      - [Data Analysis](#data-analysis)
      - [Data Validation](#data-validation)
    - [Setup and usage in Windows environment](#setup-and-usage-in-windows-environment)
      - [1. Download required 3rd party softwares:](#1-download-required-3rd-party-softwares)
      - [2. Enable developer mode in Windows](#2-enable-developer-mode-in-windows)
      - [3. Create virtual environment](#3-create-virtual-environment)
      - [4. Create configuration file](#4-create-configuration-file)
      - [5. Run the software](#5-run-the-software)
      - [6. Compare results](#6-compare-results)
    - [Available commands](#available-commands)
      - [1. ca-run](#1-ca-run)
      - [2. ca-compare](#2-ca-compare)
    - [Configuration files](#configuration-files)
    - [Acknowledgement](#acknowledgement)


  Change-Analyzer (CA in short) is a framework built utilizing ML techniques, leveraging [OpenAI Gym library](https://gym.openai.com/) and [LudwigAI framework](https://ludwig-ai.github.io/ludwig-docs/0.5/).
  CA allows product teams to get feedback regarding their software product, aka SUT (System Under Test).


  Essentially, is built around the following main Data features:
  * [Data Collection](#data-collection), done through Automated Exploratory Testing
  * [Data Reconstruction](#data-reconstruction), done through Automated Regression Testing
  * [Data Analysis](#data-analysis), done through Change Detection
  * [Data Validation](#data-validation), done through Verdict Generation


  After installation and configuration (see sections below) Data Collection can be started.
  An agent is exploring the SUT without prior knowledge of it, recording testing sequence and state of the application.
  Once the execution is completed, the Data is saved in a csv file, available in a dedicated folder, from recordings.
  Currently, the Data consists of the following information regarding the steps of the executed sequence:
  * [Timestamp](#): an Integer with the execution time in epoch
  * [SequenceId](#): a String with a unique ID to identify the sequence
  * [PageSourceBefore](#): a String with the page source (before step execution)
  * [PageSourceAfter](#): a String with the page source (after step execution)
  * [ActionToPerform](#): a String with the action that will be performed next
  * [ActionImageBefore](#): a numpy.ndarray with the image of SUT (before step execution)
  * [ActionImageAfter](#): a numpy.ndarray with the image of SUT (after step execution)


  Once several sequences exist, they can be used for Data Reconstruction.
  An agent is rerunning the specified existing sequence, recording a new state of the application.
  Data collected has the same structure as described in the above section.


  In this phase, two sequences are analyzed. The sequences are the same, from steps perspective, but are executed against
  different SUT versions (deltas).</br>
  A report is created, to showcase the differences between the two sequences, if any. The goal is to provide a visual tool
  for change detection.</br>
  The report will contain the following info:
  * The info regarding which is the expected sequence and which is the actual sequence
  * A visual indicator for each step if it was considered passed or failed
  * A description of the executed steps step
  * A short info to support the step status
  * Expected image of the SUT, from expected sequence
  * Actual image of the SUT, from actual sequence
  * Actual and expected images may contain highlighted elements, if they were detected to be part of a change


  Using ML techniques, in this phase, the tool should be able to say if the detected changes are expected behavior of faults in the SUT.
  Data Validation will be cover in more details later, because currently is in planning phase.



  * Download <a href="https://www.selenium.dev/downloads/">Selenium standalone server</a>.
    * Version 3.141.59 confirmed as working.
    * Put .jar file to place where you can easily find it.
  * FOR DESKTOP APP TESTING: Download <a href="https://github.com/microsoft/WinAppDriver">Windows Application Driver</a>.
    * Version 1.2.1 confirmed as working.
    * Install downloaded .msi file.
  * FOR WEBSITE TESTING: Download <a href="https://chromedriver.chromium.org/downloads">Chrome driver</a>.
    * Version 94.0.4606.61 confirmed as working.
    * Put binary file to place where you can easily find it.


  * Windows logo -> developer settings -> Enable
    * <a href="https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development#accessing-settings-for-developers">Official documentation</a> if needed.



  Requires Python 3.7 or newer installed and added to PATH variable.

  * Run ```install.bat``` located in source code root directory.
    * This script will install necessary dependencies defined in setup.py.


  If preferred, it is also possible to use a Conda environment.

  * Open an Anaconda terminal and go to project's main folder
  * Run `conda env create -f requirements.yml`
  * The above command will create the conda environment `change_analyzer` including all the needed dependencies
  * In order to use the Conda environment, you can either attach it to a project within your favorite IDE, or activate
  it on command line with `conda activate change_analyzer`


  It's mandatory to tell change-analyzer how to execute testing. For this reason .ini configuration is needed. Create configure now before running the software.
    * <a href="#configuration-files">More details</a> can be found in later part of this README.


  Requires Java 8 installed and added to PATH variable.

  * Start Selenium standalone server:
    * Open CMD and change directory to Selenium directory (downloaded in step 1).
    * ```java -jar selenium-server-standalone-[version].jar```
      * Version needs to be change accordingly.
    * Minimize CMD and let it run on background.
  * FOR DESKTOP APP TESTING: Start Windows Application Driver
    * Run ```WinAppDriver.exe```
      * Default location C:\Program Files (x86)\Windows Application Driver
    * Minimize CMD and let it run on background.
  * FOR WEBSITE TESTING:
    * Run ```chromedriver.exe```
    * Minimize CMD and let it run on background.
  * Run the software:
    * Open CMD and change directory to source code root.
    * Activate virtual environment: ```.venv\Scripts\activate```
    * Generate new report: ```ca-run --config [configuration filename].ini```
  * Results appear in *recordings* directory.


  Requires two generated test results.

  * Open CMD and change directory to source code root.
  * Activate virtual environment: ```.venv\Scripts\activate```
  * Compare results: ```ca-compare --sequence1_folder [Test folder 1] --sequence2_folder [Test folder 2]```
    * Replace `[Test folder 1]` with real results folder name (example 2021_10_05-14_15_00).
    * Test results are generated to *recordings* directory.
    * Argument paths starts from *recordings* directory.




  It is used to explore a given application and generate new test results.


  * `--config` (mandatory) - Defines which .ini file to use. Currently, Windows and Web platforms are supported.
  * `--csv_folder` (optional) - it triggers the Replay mode. Replay will run the sequence found within the csv_folder.
  * `--steps`(optional) - it represents the number of total steps desired for the sequence to have (default is 10)
  * `--strategy`(optional) - it defines the agent strategy, either random or rl (reinforcement learning)
  * `--model_dir` (optional) - it specifies the name of the pretrained model to use from pretrained_models folder


  Results can be found within `recordings` folder in a dedicated sub-folder.


  1a. `ca-run --config win.ini --steps 5 --strategy rl --model_dir model1`

  CA will run using the config file **win.ini** and  will aim to have a sequence of **5 steps**. It will also use
  **reinforcement learning** as strategy, with the pretrained model **model1**.

  1b. `ca-run --config web.ini --steps 15`

  CA will run using the config file **web.ini** and  will aim to have a sequence of **15 steps**. In this case,
  the strategy to get the next action is random.


  It is used to compare two test results of the same test sequence, applied to two versions of the same SUT.


  * `--sequence1_folder` (optional) - recordings folder with the **expected** test results
  * `--sequence2_folder` (optional) - recordings folder with the **actual** test results

  **Note:** If both sequences are missing, CA will attempt to find the last two test results


  Results can be found within `sequence1_folder` folder in a dedicated sub-folder.


  2a. `ca-compare --sequence1_folder 2022_08_26-12_14_34 --sequence2_folder 2022_08_26-12_24_45`

  CA will compare the test results from defined sequence1_folder (expected) and sequence2_folder (actual).


  This project uses <a href="https://docs.python.org/3/library/configparser.html">.ini files</a> as configure files to change software's behavior. **User must define own configuration files.** Ini file must define following values:
  ```
    [driver]
    command_executor=
    platform=
    app=
  ```
  Example .ini file using WinAppDriver and Windows platform:
  ```
    [driver]
    command_executor=http://127.0.0.1:4723
    platform=win
    app=/path/to/test/application.exe
  ```
  Example .ini file using SeleniumDriver and Web platform:
  ```
    [driver]
    command_executor=http://127.0.0.1:4444/wd/hub
    platform=web
    url=https://learn.ivves.eu/
  ```
  Port of command_executor needs to match the driver's (ex. WinAppDriver/chromedriver) port.


  The package was developed by [F-Secure Corporation][f-secure] in scope of [IVVES project][ivves]. This work was labelled by [ITEA3][itea3] and funded by local authorities under grant agreement 'ITEA-2019-18022-IVVES'.

  [contributing]: CONTRIBUTING.md
  [ivves]: http://ivves.eu/
  [itea3]: https://itea3.org/
  [f-secure]: https://www.f-secure.com/en


pkgId: 82049c7d9da2b77c7169b1764efb79030be7f8066ee30bc70d20d42add91db44
name: python-changeguard
arch: src
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/realazthat/changeguard
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changeguard-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  CLI to check if any of the original files in a repository/directory change over the course of a precommit script.

description:
  <!--

  WARNING: This file is auto-generated by snipinator. Do not edit directly.
  SOURCE: `README.md.jinja2`.

  -->
  <!--


  -->



  ![Top language][9] ![GitHub License][3] [![PyPI - Version][4]][5]
  [![Python Version][8]][5]

  |         | Status                     | Stable                    | Unstable                  |                    |
  | ------- | -------------------------- | ------------------------- | ------------------------- | ------------------ |
  | Master  | [![Build and Test][1]][2]  | [![since tagged][6]][10]  |                           | ![last commit][7]  |
  | Develop | [![Build and Test][11]][2] | [![since tagged][12]][13] | [![since tagged][15]][16] | ![last commit][14] |

  CLI to check if your repository/directory files have changed over the span of a
  script.



  Like hashdeep, but customized to check if any of the original files in a
  repository/directory change over the course of a precommit script.



  - Can use any sha256sum-like command (uses xxhash by default).
  - Use `.changeguard-ignore` to ignore files that should not be checked for
    changes.







  - WSL2 Ubuntu 20.04, Python 3.8.0
  - Ubuntu 20.04, Python 3.8.0, 3.9.0, 3.10.0, 3.11.0, 3.12.0, tested in GitHub
    Actions workflow
    ([build-and-test.yml](./.github/workflows/build-and-test.yml)).

  **Requirements:**

  - Linux-like environment
    - Why: Uses pexpect.spawn().
  - Python 3.8+
    - Why: Some dev dependencies require Python 3.8+.

  ```bash

  pip install changeguard


  pip install git+https://github.com/realazthat/changeguard.git@v0.3.1
  ```







  - For running `pre.sh` (Linux-like environment).
    - Requires `pyenv`, or an exact matching version of python as in
      [`.python-version`](./.python-version).
    - `nvm` for prettier (markdown formatting).
    - `bash`, `grep`, `xxd`, `git`, `xxhash` (for scripts/workflows/tests).
    - `jq`, ([installation](https://jqlang.github.io/jq/)) required for
      [yq](https://github.com/kislyuk/yq), which is itself required for our
      `README.md` generation, which uses `tomlq` (from the
      [yq](https://github.com/kislyuk/yq) package) to include version strings from
      `pyproject.toml`.
    - Requires `nodejs` (for act).
    - Requires `go` (to run act).
    - `docker` (for act).



  1. (Optionally) Fork the `develop` branch.
  2. Stage your files: `git add path/to/file.py`.
  3. `bash scripts/pre.sh`, this will format, lint, and test the code.
  4. `git status` check if anything changed (generated `README.md` for
     example), if so, `git add` the changes, and go back to the previous step.
  5. `git commit -m "..."`.
  6. Make a PR to `develop` (or push to develop if you have the rights).



  These instructions are for maintainers of the project.

  1. `develop` branch: Run `bash scripts/pre.sh` to ensure everything
     is in order.
  2. `develop` branch: Bump the version in `pyproject.toml`, following
     semantic versioning principles. Also modify the `last_unstable_release` and
     `last_stable_release` in the `[tool.changeguard-project-metadata]` table as
     appropriate.
  3. `develop` branch: Commit these changes with a message like "Prepare release
     X.Y.Z". (See the contributions section [above](#commit-process)).
  4. `master` branch: Merge the `develop` branch into the `master` branch:
     `git checkout master && git merge develop --no-ff`.
  5. `master` branch: Tag the release: Create a git tag for the release with
     `git tag -a vX.Y.Z -m "Version X.Y.Z"`.
  6. Publish to PyPI: Publish the release to PyPI with
     `bash scripts/deploy-to-pypi.sh`.
  7. Push to GitHub: Push the commit and tags to GitHub with `git push` and
     `git push --tags`.
  8. `git checkout develop && git merge master` The `--no-ff` option adds a commit
     to the master branch for the merge, so refork the develop branch from the
     master branch.
  9. `git push origin develop` Push the develop branch to GitHub.

  [1]:
    https://github.com/realazthat/changeguard/actions/workflows/build-and-test.yml/badge.svg?branch=master
  [2]:
    https://github.com/realazthat/changeguard/actions/workflows/build-and-test.yml
  [3]: https://img.shields.io/github/license/realazthat/changeguard
  [4]: https://img.shields.io/pypi/v/changeguard
  [5]: https://pypi.org/project/changeguard/
  [6]:
    https://img.shields.io/github/commits-since/realazthat/changeguard/v0.3.1/master
  [7]: https://img.shields.io/github/last-commit/realazthat/changeguard/master
  [8]: https://img.shields.io/pypi/pyversions/changeguard
  [9]:
    https://img.shields.io/github/languages/top/realazthat/changeguard.svg?&cacheSeconds=28800
  [10]:
    https://github.com/realazthat/changeguard/compare/v0.3.1...master
  [11]:
    https://github.com/realazthat/changeguard/actions/workflows/build-and-test.yml/badge.svg?branch=develop
  [12]:
    https://img.shields.io/github/commits-since/realazthat/changeguard/v0.3.1/develop
  [13]:
    https://github.com/realazthat/changeguard/compare/v0.3.1...develop
  [14]: https://img.shields.io/github/last-commit/realazthat/changeguard/develop
  [15]:
    https://img.shields.io/github/commits-since/realazthat/changeguard/v0.3.1/develop
  [16]:
    https://github.com/realazthat/changeguard/compare/v0.3.1...develop

rpm_license:
  MIT License  Copyright (c) 2024 Azriel Fasten.  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 (including the next paragraph) 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: 2199b526add2d2f82b5a5f6d3158f1bd60147ef9c34b98abb398d7c8757e37e9
name: python-changelist
arch: src
version: 0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/changelist/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelist-0.5-1.src.rpm
checksum_type: sha256
description:
  A tool that automates release note generation.

  For example, see
  https://github.com/scientific-python/changelist/blob/main/CHANGELOG.md.

  **Features**

  - Compile a list of pull requests, code authors, and reviewers between
    two given git commits.
  - Categorize pull requests into sections based on GitHub labels.
  - Override pull request titles with more descriptive summaries.
  - Document unrelated changes in a pull requests in separate summaries.

  _This project is currently in its alpha stage and might be incomplete or change a lot!_



  ```sh
  pip install changelist
  ```



  The script requires a [GitHub personal access
  token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens).
  The token does not need any permissions, since it is used only to
  increase query limits.

  ```sh
  export GH_TOKEN='...'
  changelist scientific-python/changelist v0.2.0 main
  ```

  This will list all pull requests, authors and reviewers that touched commits
  between `v0.2.0` and `main` (excluding `v0.2.0`).
  Pull requests are sorted into sections according to the configuration in
  `tool.changelist.label_section_map`.



  By default, changelist will fall back to the title of a pull request and its
  GitHub labels to sort it into the appropriate section. However, if you want
  longer summaries of your changes you can add a code block with the following
  form anywhere in the description of the pull request:

      ```release-note
      An ideally expressive description of the change that is included as
      a single bullet point. Newlines are removed.
      ```

  Sometimes pull requests introduce multiple changes that should be listed in different
  sections. For that reason, a summary block like above can be used more than
  once. Additionally, you can add independent labels to each summary by adding a
  `{label="..."}` anywhere in the summary. These labels are sorted the same way
  as regular pull request labels are. E.g. the two summaries below will go into
  separate sections:

      ```release-note {label="Bug fix"}
      Make `is_odd()` work for negative numbers.
      ```

      ```release-note
      Deprecate `ìs_odd`; use `not (x % 2)` instead! {label="API, Highlight"}
      ```



  changelist can be configured from two sources, in order of precedence:

  - A local TOML file specified with the `--config` option
  - A remote `pyproject.toml` at `stop_rev`

  If a configuration option is not specified in either file above, changelist
  falls back to the following configuration:

  <!--- Changes to the following block are overridden by a pre-commit hook! --->
  <!--- begin default_config.toml --->

  ````toml

  [tool.changelist]




  title_template = "{repo_name} {version}"




  intro_template = """
  We're happy to announce the release of {repo_name} {version}!
  """




  outro_template = """
  _These lists are automatically generated, and may not be complete or may contain
  duplicates._
  """


  ignored_user_logins = [
      "web-flow",
  ]














  pr_summary_regex = "^```release-note\\s*(?P<summary>[\\s\\S]*?\\w[\\s\\S]*?)\\s*^```"


















  pr_summary_label_regex = """{[^}]*?label=[\\"](?P<label>[^\\"]+)[^}]*?}"""






  [tool.changelist.label_section_map]
  ".*Highlight.*" = "Highlights"
  ".*New feature.*" = "New Features"
  ".*API.*" = "API Changes"
  ".*Enhancement.*" = "Enhancements"
  ".*Performance.*" = "Performance"
  ".*Bug fix.*" = "Bug Fixes"
  ".*Documentation.*" = "Documentation"
  ".*Infrastructure.*" = "Infrastructure"
  ".*Maintenance.*" = "Maintenance"
  ````

  <!--- end default_config.toml --->



  To categorize merged PRs in the changelist with the default configuration, each
  PR must have a label that matches one of the regexes on the left side of the
  `label_section_map` table, e.g. `type: Highlights`.



  You may want to ensure that each PR has an associated `type: ` label,
  we recommend adding an action that fails CI if the label is missing.

  To do so, place the following in `.github/workflows/label-check.yaml`:

  <!--- Changes to the following block are overridden by a pre-commit hook! --->
  <!--- begin label-check.yaml --->

  ```yaml
  name: Labels

  on:
    pull_request:
      types:
        - opened
        - reopened
        - labeled
        - unlabeled
        - synchronize

  env:
    LABELS: ${{ join( github.event.pull_request.labels.*.name, ' ' ) }}

  jobs:
    check-type-label:
      name: ensure type label
      runs-on: ubuntu-latest
      steps:
        - if: "contains( env.LABELS, 'type: ' ) == false"
          run: exit 1
  ```

  <!--- end label-check.yaml --->



  Often, it is helpful to have milestones that reflect the actual PRs
  merged. We therefore recommend adding an action that attached the
  next open milestone to any merged PR.

  To do so, place the following in `.github/workflows/milestone-merged-prs.yaml`:

  <!--- Changes to the following block are overridden by a pre-commit hook! --->
  <!--- begin milestone-merged-prs.yaml --->

  ```yaml
  name: Milestone

  on:
    pull_request_target:
      types:
        - closed
      branches:
        - "main"

  jobs:
    milestone_pr:
      name: attach to PR
      runs-on: ubuntu-latest
      steps:
        - uses: scientific-python/attach-next-milestone-action@bc07be829f693829263e57d5e8489f4e57d3d420
          with:
            token: ${{ secrets.MILESTONE_LABELER_TOKEN }}
            force: true
  ```

  <!--- end milestone-merged-prs.yaml --->

  See https://github.com/scientific-python/attach-next-milestone-action for more information.

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


pkgId: 767135c834a48170732bbc9e5b0a4cb5498e4b24a3b6e7129c3023bf4948a415
name: python-changelist-data
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Data Management base package for Changelists CLI Tools
url: https://github.com/DK96-OS/changelist-data/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelist-data-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Data Management for Changelists CLI Tools.


  This package is designed for the purpose of serving other changelist packages, and reducing code duplication.


  There are two storage options for Changelists.
  - The first is the `.idea/workspace.xml` file associated with popular IDEs.
  - The second is a dedicated `.changelists/data.xml` file managed by changelist-data on behalf of other changelist tools.

  Each changelist tool must be compatible with both storage options. The goal of this package is to provide access to both storage options, and support the file reading and writing needs of all changelist tools.


  The Data Storage needs of the Changelist Tools:
  - Changelist Init
      - Create New Changelists File
      - Find Existing Storage File
      - Update Existing Storage File (with git status info)
  - ChangeList Sort
      - Find Existing Storage File
      - Load Existing Storage File
      - Update Existing Storage File
  - ChangeList FOCI
      - Find Existing Storage File
      - Read Existing Storage File


  `class FileChange` : Individual Files
  - before_path: str | None = None
  - before_dir: bool | None = None
  - after_path: str | None = None
  - after_dir: bool | None = None

  `class Changelist` : Lists of Files
  - id: str
  - name: str
  - changes: list[FileChange] = field(default_factory=lambda: [])
  - comment: str = ""
  - is_default: bool = False


  Call the public methods of the appropriate package for the level of detail required.
  - `changelist_data/` contains high level methods with default options for accessing storage files
  - `changelist_data/storage/` contains storage option specific methods for read-only and writable access.
  - `changelist_data/xml/` contains some simple xml modules, and two subpackages.
  - `changelist_data/xml/changelists/` changelists data xml management.
  - `changelist_data/xml/workspace/` workspace xml management.


  The highest level package should contain the highest level methods and modules.


  - `read_default() -> list[Changelist]`
  - `load_default() -> ChangelistDataStorage`
  - `write_tree(ChangelistDataStorage, Path) -> bool`

  **Storage File Management**:
  - Find Existing Storage File and Read or Load it (Default is Changelists data xml)
  - Search for Storage File via Argument (workspace file argument backwards compatibility)
  - Create Changelists Data File if not exists

  **Read-Only Changelist Requirements**:
  - Find and Read the Workspace File into a List of Changelist data objects
  - Find and Read the Changelists Data File into a List of Changelist data objects

  **Loading Changelist Data Tree Structures**:
  - Existing File is Loaded into one of the two Tree classes
  - Tree classes handle updates to the storage data file


  This package contains modules for both workspace and changelist storage options.
  Each option provides a reader and a tree loader.

  - `read_changelists_storage(Path) -> list[Changelist]`
  - `read_workspace_storage(Path) -> list[Changelist]`
  - `load_changelists_tree(Path) -> ChangelistsTree`
  - `load_workspace_tree(Path) -> WorkspaceTree`


  This module determines if a storage option is already in use (one of those files exists).
  - Check if `.idea/workspace.xml` exists
  - Check if `.changelists/data.xml` exists
  - Check given workspace_xml or data_xml file argument exists
  - Validate the Input File, prevent loading any file over 32MB


  This package provides all the methods one may need for processing Changelists XML.
  - `read_xml(changelists_xml: str) -> list[Changelist]`
  - `load_tree(changelists_xml: str) -> ChangelistsTree`
  - `new_tree() -> ChangelistsTree`

  The `new_tree` method is a shortcut for creating a Changelists XML Tree.
  This is to be used when initializing changelist workflows for the first time in a project.


  This package provides methods for processing Workspace XML.
  - `read_xml(workspace_xml: str) -> list[Changelist]`
  - `load_tree(workspace_xml: str) -> WorkspaceTree`


pkgId: 0d31f27a390c3048801946126f835a025687aaa009452b83bbd533d1746a9fca
name: python-changelist-data
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Data Management base package for Changelists CLI Tools
url: https://github.com/DK96-OS/changelist-data/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelist-data-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Data Management for Changelists CLI Tools.


  This package is designed for the purpose of serving other changelist packages, and reducing code duplication.


  There are two storage options for Changelists.
  - The first is the `.idea/workspace.xml` file associated with popular IDEs.
  - The second is a dedicated `.changelists/data.xml` file managed by changelist-data on behalf of other changelist tools.

  Each changelist tool must be compatible with both storage options. The goal of this package is to provide access to both storage options, and support the file reading and writing needs of all changelist tools.


  The Data Storage needs of the Changelist Tools:
  - Changelist Init
      - Find & Update Existing Storage File
      - Create New Changelists File
  - ChangeList Sort
      - Find, Load & Update Existing Storage File
  - ChangeList FOCI
      - Find & Read Existing Storage File


  Call the public methods of the appropriate package for the level of detail required.
  - `changelist_data/` contains shared data classes.
  - `changelist_data/storage/` contains storage methods for read and write access.
  - `changelist_data/xml/` contains some xml tree abstractions and modules.
  - `changelist_data/xml/changelists/` changelists data xml management.
  - `changelist_data/xml/workspace/` workspace xml management.


  The highest level package does not import anything during initialization, or provide package level methods.
  It contains the common data classes shared by Changelist packages.


  `class FileChange` : Individual Files
  - before_path: str | None = None
  - before_dir: bool | None = None
  - after_path: str | None = None
  - after_dir: bool | None = None

  `class Changelist` : Lists of Files
  - id: str
  - name: str
  - changes: list[FileChange] = field(default_factory=lambda: [])
  - comment: str = ""
  - is_default: bool = False


  This package contains modules for both workspace and changelist storage options.
  The storage option is passed in as an enum. Sensible default values are included.
  - `read_storage(StorageType, Path) -> list[Changelist]`
  - `load_storage(StorageType, Path) -> ChangelistsDataStorage`

  **Storage File Management**:
  - Find Existing Storage File and Read or Load it (Default is Changelists data xml)
  - Search for Storage File via Argument (workspace file argument backwards compatibility)
  - Create Changelists Data File if not exists

  **Read-Only Changelist Requirements**:
  - Find and Read the Workspace File into a List of Changelist data objects
  - Find and Read the Changelists Data File into a List of Changelist data objects

  **Loading Changelist Data Tree Structures**:
  - Existing File is Loaded into one of the two Tree classes
  - Tree classes handle updates to the storage data file


  This module determines if a storage option is already in use (one of those files exists).
  - Check if `.idea/workspace.xml` exists
  - Check if `.changelists/data.xml` exists
  - Check given workspace_xml or data_xml file argument exists
  - Validate the Input File, prevent loading any file over 32MB


  This package provides all the methods one may need for processing Changelists XML.
  - `read_xml(changelists_xml: str) -> list[Changelist]`
  - `load_tree(changelists_xml: str) -> ChangelistsTree`
  - `new_tree() -> ChangelistsTree`

  The `new_tree` method is a shortcut for creating a Changelists XML Tree.
  This is to be used when initializing changelist workflows for the first time in a project.


  This package provides methods for processing Workspace XML.
  - `read_xml(workspace_xml: str) -> list[Changelist]`
  - `load_tree(workspace_xml: str) -> WorkspaceTree`


pkgId: 73eb0a9e577331933c269cc78b2d085f4e2cd08819d9ac84e339b7f5316f1c7e
name: python-changelist-init
arch: src
version: 0.1
epoch: 0
release: 1
summary: Initialize and update Changelists information.
url: https://github.com/DK96-OS/changelist-init/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelist-init-0.1-1.src.rpm
checksum_type: sha256
description:
  Manage your Git File and Commit Message Workflows with Changelists!


  Changelist-Init is the package that gets your changelists ready to go!
  - Sync changelists with **git**.
  - Creates new changelists data file if necessary.


  Changelist-Init is a command-line tool (CLI) in an ecosystem of Changelist CLI tools.
  It plays the role of adding file changes from **git** into the project changelist data file.

  The related packages `sort` and `foci` serve other changelist management functions by reading, and writing to, the project changelist data file.


  The package `changelist-sort` is for organizing the files in your Changelists.
  - Sorts files into Changelists by directory

  The package `changelist-foci` (File Oriented Commit Information) prints a commit message template for your Changelists.
  - Various File Name and Path formatting options




  The root package init module provides high level methods:
  - `initialize_file_changes() -> list[FileChange]`: Get updated FileChange information from Git.
  - `merge_file_changes() -> bool`: Merge updated FileChange information into Changelists.


  Using the High-Level package method `validate_input`, converts program arguments into `InputData` object.
  Parsing and Validation are handled by internal package modules.


  **Argument Data**:
  - changelists_file: The string path to the Changelists Data File.
  - workspace_file: The string path to the Workspace File.
  - include_untracked: Whether to include untracked files.

  **Input Data**:
  - storage: The ChangelistData Storage object.
  - include_untracked: Whether untracked files are added to changelists. false by default.


  **Argument Parser**
  **String Validation**


  Use the `get_status_lists()` method to obtain updated file information from git.



  **Git File Status**:
  - `get_tracking_status()`

  **Git Status Lists**: A Collection of Data processed from Git Status operation.
  - `get_list(GitTrackingStatus) -> list[GitFileStatus]`
  - `add_file_status(GitFileStatus)`



  **Git Tracking Status**:
  - UNTRACKED
  - UNSTAGED
  - STAGED
  - PARTIAL_STAGE



  **Status Runner**:
  - `run_git_status() -> str`: Runs a Git Status short operation, returns the stdout.

  **Status Reader**:
  - `read_git_status_output(str) -> GitStatusLists`: Read Git Status short stdout.
  - `read_git_status_line(str) -> GitFileStatus | None`: Read a single line of Git Status short.

  **Status Codes**:
  - `get_status_code_change_map(str) -> Callable[]`: Construct a FileChange map function for a Git Status code.


pkgId: 522c3451416e7d5b52344e3a99d5bc6f90194caa50678922bc08378affccbdec
name: python-changelist-sort
arch: src
version: 0.3
epoch: 0
release: 1
summary: CLI Tool for Sorting Android Studio Changelists
url: https://github.com/DK96-OS/changelist-sort/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelist-sort-0.3-1.src.rpm
checksum_type: sha256
description:
  Making Sorting Changelist Files Easy!

  1. Close Android Studio (saves changelists to workspace file)
  2. Open shell from project root directory (or supply workspace file path in arguments)
  3. Run `changelist-sort` (or `cl-sort`) add arguments/options if necessary
  4. Reopen Android Studio. Your changelists are sorted.

  **Note:** If you want to combine step 2 and step 3, add an alias to your shell environment.


  Files are sorted by the name of the top level directory they are located in.
  In Android projects, each directory in the project root is a module, with a few special cases.


  A specialized Module Sort mode that splits changes by their source set.
  Apply the `-s` flag to use this sorting mode.


  There are special Changelists, and special Directories that are handled differently.
  - Build Updates Changelist
  - Root Directory
  - Gradle Directory

  **Build Updates Changelist:**
  This is a changelist that is used to collect all of the files that affect the project build.
  This includes all files in the gradle directory, and any file that ends with the `.gradle` file extension. There are also Gradle files that end in `.properties`, which are also sorted into the **Build Updates** Changelist.

  **Root Directory:**
  The Root directory is special because the file paths are really short and do not contain a module name. Often, Root directory contains `.gradle` files which are sorted into the Build Updates Changelist. Any non-Gradle files in the Root directory are sorted into a special Changelist that may be called `Root` or `Project Root`.

  **Gradle Directory:**
  The Gradle Directory is a direct descendant of the Root directory, and may contain `toml`, `gradle`, or `properties` files. These are all sorted into the **Build Updates** Changelist.



  **Changelist Names**
  The name of the changelist must match the module, ignoring letter case and removing spaces.

  Otherwise, a new Changelist will be created that matches the module name.
  - Underscores are replaced with spaces.
  - Each Word in the Name will start with an uppercase letter.


  You can remove all empty changelists after a sort has completed by adding the `-r` flag, or `--remove-empty` argument.


pkgId: 8a5bf2d35a1e6ab5db184b4b2d875fbafa686a0a71b6af6c3fb9ce96e0de248c
name: python-changelist-sort
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: CLI Tool for Sorting Android Studio Changelists
url: https://github.com/DK96-OS/changelist-sort/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelist-sort-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Making Sorting Changelist Files Easy!

  1. Close Android Studio (saves changelists to workspace file)
  2. Open shell from project root directory (or supply workspace file path in arguments)
  3. Run `changelist-sort` (or `cl-sort`) add arguments/options if necessary
  4. Reopen Android Studio. Your changelists are sorted.

  **Note:** Add alias to your shell environment to maximize your efficiency.


  To configure a changelist sorting patterns for your project:
  1. Create Directory `.changelists/`
  2. Create File `sort.xml` in Directory
  3. Write Sorting XML Root Tag `<sorting></sorting>`
  4. Write Changelists Tags `<changelist name="" key=""></changelist>`
  5. Write File Pattern Tags `<files ... /> `


  For each `<files />` tag, apply ONE of the following attributes:
  - file_ext : Match the file extension of the file. Do not include the dot.
  - first_dir : The first directory in the path. Use empty string to match root directory.
  - filename_prefix : The filename startswith this prefix.
  - filename_suffix : The filename endswith this prefix.
  - path_start : The beginning of the parent directory path. It's usually better to exclude unnecessary slash characters.
  - path_end : The end of the parent directory path. It's usually better to exclude unnecessary slash characters.


  The `key` attribute inside changelists is required.
  - Sorting Keys are short, simple strings that identify a changelist.
  - More than one Sorting Key can map to one Changelist.
  - Every File pattern is associated with a Sorting Key.


  Files are sorted by the name of the top level directory they are located in.
  In Android projects, each directory in the project root is a module, with a few special cases.


  A specialized Module Sort mode that splits changes by their source set.
  Apply the `-s` flag to use this sorting mode.


  There are special Changelists, and special Directories that are handled differently.
  - Build Updates Changelist
  - Root Directory
  - Gradle Directory

  **Build Updates Changelist:**
  This is a changelist that is used to collect all of the files that affect the project build.
  This includes all files in the gradle directory, and any file that ends with the `.gradle` file extension. There are also Gradle files that end in `.properties`, which are also sorted into the **Build Updates** Changelist.

  **Root Directory:**
  The Root directory is special because the file paths are really short and do not contain a module name. Often, Root directory contains `.gradle` files which are sorted into the Build Updates Changelist. Any non-Gradle files in the Root directory are sorted into a special Changelist that may be called `Root` or `Project Root`.

  **Gradle Directory:**
  The Gradle Directory is a direct descendant of the Root directory, and may contain `toml`, `gradle`, or `properties` files. These are all sorted into the **Build Updates** Changelist.



  **Changelist Names**
  The name of the changelist must match the module, ignoring letter case and removing spaces.

  Otherwise, a new Changelist will be created that matches the module name.
  - Underscores are replaced with spaces.
  - Each Word in the Name will start with an uppercase letter.


  You can remove all empty changelists after a sort has completed by adding the `-r` flag, or `--remove-empty` argument.


pkgId: 01a2054f03492b2ed3551aed9fc5ec376246881cf0f9e10c2eb3ae66c04e412f
name: python-changelog-gen
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Changelog generation tool
url: https://pypi.org/project/changelog-gen/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelog-gen-0.13.2-1.src.rpm
checksum_type: sha256
description:
  [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
  [![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)
  [![image](https://img.shields.io/pypi/v/changelog_gen.svg)](https://pypi.org/project/changelog_gen/)
  [![image](https://img.shields.io/pypi/l/changelog_gen.svg)](https://pypi.org/project/changelog_gen/)
  [![image](https://img.shields.io/pypi/pyversions/changelog_gen.svg)](https://pypi.org/project/changelog_gen/)
  ![style](https://github.com/NRWLDev/changelog-gen/actions/workflows/style.yml/badge.svg)
  ![tests](https://github.com/NRWLDev/changelog-gen/actions/workflows/tests.yml/badge.svg)
  [![codecov](https://codecov.io/gh/NRWLDev/changelog-gen/branch/main/graph/badge.svg)](https://codecov.io/gh/NRWLDev/changelog-gen)



  `changelog-gen` is a CHANGELOG generator, to detect semantic versioning changes
  from conventional commits, and generate release tags.

  See the [docs](https://nrwldev.github.io/changelog-gen) for more details.



  `changelog init` will generate an empty changelog file if you have not been
  maintaining changelogs previously. If you already have a changelog file, it
  will be detected.

  `changelog generate` will extract all commits matching the conventional format
  since the last release, detect the correct semantic version component to
  increment, and generate the correct changelog entry. Depending on
  configuration, it will also update release tags in files as well as tagging the
  release.

  ```bash
  $ git log --oneline
  a4e1449 feat: Open changes in editor before confirmation, to allow modification.
  c314b6b feat: Block generation if local/remote are out of sync.
  2e25deb chore: Relax typer version to 0.X
  a95fd80 fix: Handle warning message from bump-my-version if setup.cfg exists
  b46d2fe fix: Clean up link generation format in MDWriter
  ```

  Using the above commits, can generate the following example changelog entry.

  ```md





  - Open changes in editor before confirmation, to allow modification. [[#1](https://github.com/NRWLDev/changelog-gen/issues/1)] [[a4e1449](https://github.com/NRWLDev/changelog-gen/commit/a4e1449bf44f370c671cc679d4bf9cfd75e68cbf)]
  - Block generation if local/remote are out of sync. [[#2](https://github.com/NRWLDev/changelog-gen/issues/2)] [[c314b6b](https://github.com/NRWLDev/changelog-gen/commit/c314b6b8a32f4ce5c05869f0accd24bb4e6097f2)]


  - Handle warning message from bump-my-version if setup.cfg exists [[a95fd80](https://github.com/NRWLDev/changelog-gen/commit/a95fd80d939985ab4b51a864676dda234e345d47)]
  - Clean up link generation format in MDWriter [[b46d2fe](https://github.com/NRWLDev/changelog-gen/commit/b46d2fe6fba5a170f25dffbf8697868d14a4e73e)]


  - Relax typer version to 0.X [[2e25deb](https://github.com/NRWLDev/changelog-gen/commit/2e25deb902710343a0f85f40323762752eef4a45)]
  ```


  Check the discussion
  [here](https://github.com/EdgyEdgemond/changelog-gen/discussions/98) for
  details on how to update usage to maintain legacy functionality or move over to
  new features.



  ```bash
  pip install changelog-gen
  ```

  or clone this repo and install with invoke/uv.

  ```bash
  invoke install-dev
  ```



  This project uses pre-commit hooks, please run `invoke install-dev` after
  cloning to install dev dependencies and commit hooks.


pkgId: a0f7e641cd965384f90631105d5abd2b58ca0dddfa65f79bc596d41f88f57af3
name: python-changelogged
arch: src
version: 0.13.0
epoch: 0
release: 1
url: https://github.com/award28/changelogger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changelogged-0.13.0-1.src.rpm
checksum_type: sha256
summary:
  Automated management of your changelog and other versioned files, following the principles of Keep a Changelog and Semantic Versioning.

description:
  With that, we now understand how the Changelogger configuration file works.
  Now all you need to do is let Changelogger do the heavy lifting for any
  upgrade with the `manage upgrade`. Make sure to explore what commands are
  available by using the `changelogger --help` command!

  This section reviews all available configuration sections of the Changelogger
  configuration file. For a more streamlined introduction, review the
  [introduction](#introduction) section. The
  [JSON Schema Core](https://json-schema.org/latest/json-schema-core.html)
  compliant schema can be found in the
  [config.schema.json](../config.schema.json) file.
  The `changelog` field is used for managing and updating the `CHANGELOG.md`.
  If your project doesn't follow the standard changelog file format prescribed
  by Changelogger, you will need to upate this section. **Note** that the changelog
  section requires both the overview and links sub sections be provided. However,
  if there are other versioned changes you would like to require Changelogger manage
  on your behalf, you can add those to the `versioned_files` section.
  *Example File with All Required Fields*
  ```yml
  changelog:
    rel_path: "CHANGELOG.md"
    overview:
      pattern: '### \[Unreleased\]([\s\S]*)### \[{{ old_version }}]'
      template: ./templates/.cl.overview.jinja2
    links:
      pattern: '\[Unreleased\]:.*\n'
      template: ./templates/.cl.links.jinja2
  versioned_files:
    - rel_path: "pyproject.toml"
      pattern: 'version = "{{ old_version }}"'
      jinja: 'version = "{{ new_version }}"'
  ```

  The following is an overview of the jinja variables available in the `pattern`
  field and the `jinja` templating for managed replacement.

  The new version after the requested semantic version bump type has been applied.

  *.some.jinja2*
  ```jinja
  New Version: {{ new_version }}
  ```

  The current version of the project, which the requested semantic version bump type
  will be applied on.

  *.some.jinja2*
  ```jinja
  Old Version: {{ old_version }}
  ```

  A [datetime.date](https://docs.python.org/3/library/datetime.html#date-objects)
  object with today's date.

  *.some.jinja2*
  ```jinja
  Todays Date: {{ today }}
  ```

  A map from each section of the Keep a Changelog standard to the notes included for
  that section.

  *.some.jinja2*
  ```jinja
  {% for name, notes in sections.items() -%}
  {% if notes -%}

  {% for note in notes -%}
  - {{ note }}
  {% endfor %}
  {% endif %}
  { endfor -%}
  ```

  User specified context in the `.changelogger.yml` configuration file, available in
  both the pattern and jinja through dot notation.

  *.changelogger.yml*
  ```yml
  versioned_files:
    - rel_path: "pyproject.toml"
      pattern: 'version = "{{ old_version }}"'
      template: '.pyproject.toml.jinja2'
      context:
        git:
          org: award28
          repo: changelogger
  ```
  *.pyproject.toml.jinja2*
  ```jinja
  org: {{ context.git.org }}
  repo: {{ context.git.repo }}
  ```


pkgId: cbc42a7cb8c1a4188ab5f911ed3b6b4ef74d94463cd13c0b05cda8fd67a7e8cb
name: python-changeo
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A bioinformatics toolkit for processing high-throughput lymphocyte receptor sequencing data.
url: http://changeo.readthedocs.io
rpm_license: GNU Affero General Public License 3 (AGPL-3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-changeo-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Change-O is a collection of tools for processing the output of V(D)J alignment
  tools, assigning clonal clusters to immunoglobulin (Ig) sequences, and
  reconstructing germline sequences.
  Dramatic improvements in high-throughput sequencing technologies now enable
  large-scale characterization of Ig repertoires, defined as the collection of
  trans-membrane antigen-receptor proteins located on the surface of B cells and
  T cells. Change-O is a suite of utilities to facilitate advanced analysis of
  Ig and TCR sequences following germline segment assignment. Change-O
  handles output from IMGT/HighV-QUEST and IgBLAST, and provides a wide variety of
  clustering methods for assigning clonal groups to Ig sequences. Record sorting,
  grouping, and various database manipulation operations are also included.


pkgId: 6387664c1aed3b40ff867df0a70fa82e545c6555abb25f6822c887148ed08b1c
name: python-chanjo-report
arch: src
version: 4.11.1
epoch: 0
release: 1
summary: Automatically render coverage reports from Chanjo ouput
url: https://github.com/robinandeer/chanjo-report
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chanjo-report-4.11.1-1.src.rpm
checksum_type: sha256
description:
  ![Example report (eng)](artwork/screenshot.png)


  Automatically generate basic coverage reports from Chanjo SQL databases. This plugin installs as a subcommand ("report") to the Chanjo command line interface.


  Chanjo Report supports a number of output formats: tabular, PDF, and HTML. To print a PDF coverage report for a group of samples "WGS-prep" do:

  ```bash
  $ chanjo report --render pdf --group "WGS-prep" > ./coverage-report.pdf
  ```




  Chanjo Reports multiple output formats:

    - tabular: easily parsable and pipeable
    - PDF: easily distributable (for humans)
    - HTML: easily deliverable on the web


  The coverage report (HTML/PDF) can be render is the following languages:

    - English
    - Swedish



  We are using the output from Chanjo at Clincal Genomics to report success of sequencing across the exome based on coverage. Our customers, clinicians mostly, are specifically interested in knowing to what degree their genes of interest are covered by sequencing along with some intuitive overall coverage metrics. They want the output in PDF format to file it in their system.

  As a side effect of finding it easiest to convert HTML to PDF, Chanjo Report has a built in Flask server that can be used to render reports dynamically and even be plugged into other Flask servers as a Blueprint.




  The latest version of Chanjo-report can be installed by cloning and installing the repository from Clinical Genomics github:

  ```bash
  $ git clone https://github.com/Clinical-Genomics/chanjo-report.git
  $ cd chanjo-report
  $ pip install --editable .
  ```



  To run a local demo with Docker, ensure you have a Docker engine running.
  If you do not have Docker set up, we can recommend Docker Desktop (https://www.docker.com/products/docker-desktop/).

  Then use `make` with the repository `Makefile` to build and run:

  ```bash
  make build
  make setup
  make report
  ```

  Point your browser to `http://127.0.0.1:5000` and find the demo samples.



  We provide a Dockerfile to run the server in a container. To run a demo instance of the server with a pre-populated database consisting of a case with 3 samples, clone the repository using the following commands:

   ```bash
   $ git clone https://github.com/Clinical-Genomics/chanjo-report.git
   $ cd chanjo-report
   ```

  Then you could make use of the services present in the Docker-compose file following these 3 steps:

  1. Build the images

      ```bash
      make build
      ```

  2. Launch chanjo to create a populate the database with demo data

      ```bash
      make setup
      ```

  3. Launch the chanjo-report server

       ```bash
       make report
       ```

  A running instance of the server should now be available at the following url: http://localhost:5000/.

  In order to generate a report containing all 3 demo samples, use the respective request args: http://localhost:5000/report?sample_id=sample1&sample_id=sample2&sample_id=sample3

  Please be aware that if you are building and running the Dockerized version of chanjo-report, there might be **issues on `macOS` if your processor is Apple silicon** (or another `ARM64` based architecture).
  In order to build the `chanjo-report` image in the `ARM64` architecture, you can set the environment variable `DOCKER_DEFAULT_PLATFORM`:

   ```bash
   export DOCKER_DEFAULT_PLATFORM=linux/amd64
  make build
  make setup
  make report
  ```


  MIT. See the [LICENSE](LICENSE) file for more details.



  Anyone can help make this project better - read [CONTRIBUTING](CONTRIBUTING.md) to get started!


pkgId: 84d2d539bf90c4f2ad74e5339ba47a089fda129ff9304afcb64f2fc8745701a0
name: python-channel2pdf
arch: src
version: 0.0.28
epoch: 0
release: 1
summary: Export Telegram Channel to PDF
url: https://github.com/gaoyunzhi/channel2pdf
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channel2pdf-0.0.28-1.src.rpm
checksum_type: sha256
description:
  Export Telegram Channel to PDF



  ```
  import channel2pdf
  channel2pdf.gen(CHANNEL_USERNAME)
  ```



  `sudo -v && wget -nv -O- https://download.calibre-ebook.com/linux-installer.sh | sudo sh /dev/stdin`
  `pip3 install channel2pdf`


pkgId: 7c49c81591bee94a5348c9a12ec3e416741e1311e7b2fee8ce2ad0b9358df843
name: python-channelizers
arch: src
version: 1.0
epoch: 0
release: 1
url: https://github.com/WhataDavid/Channelizer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channelizers-1.0-1.src.rpm
checksum_type: sha256
summary:
  A python package for ultra bandwidth signal process, can divide signal into several narrow bandwidth signal

description:
  - Critically sampled channelizer
  - Integer-oversampled channelizer
  - Rationally-oversampled channelizer


  ```python
      
      TAPS = 63
      
      CHANNEL_NUM = 4
      
      M = CHANNEL_NUM
      
      D = 3
      
      
      

      np_data = np.loadtxt(r'\mini_data.txt')
      coe = realignment_coe(TAPS, CHANNEL_NUM, D)
      polyphase_filter_res = polyphase_filter_bank_with_denominator_z(np_data, coe, CHANNEL_NUM, D)
      fft_res = np.fft.ifft(polyphase_filter_res, axis=0)
      plot_sub(fft_res, CHANNEL_NUM, "DX " + str(CHANNEL_NUM) + "/" + str(D) + "X channelizer with z gcd result:")

      coe = realignment_coe(TAPS, CHANNEL_NUM, D)
      polyphase_filter_res = polyphase_filter_bank_with_denominator_z(np_data, coe, CHANNEL_NUM, D)
      rotate_res = circular_rotate(polyphase_filter_res, CHANNEL_NUM, D)
      fft_res = np.fft.ifft(rotate_res, axis=0)
      plot_sub(fft_res, CHANNEL_NUM,"DX " + str(CHANNEL_NUM) + "/" + str(D) + "X channelizer with z gcd and rotate result:")

      coe = realignment_coe(TAPS, CHANNEL_NUM, D)
      polyphase_filter_res = polyphase_filter_bank_with_denominator_z(np_data, coe, CHANNEL_NUM, D)
      rotate_res = circular_rotate(polyphase_filter_res, CHANNEL_NUM, D)
      cut_res = cut_extra_channel_data_by_tail(np.fft.fft(np.fft.ifft(rotate_res, axis=0)), CHANNEL_NUM,D) * D / M
      plot_sub(np.fft.ifft(cut_res), CHANNEL_NUM,"DX " + str(CHANNEL_NUM) + "/" + str(D) + "X channelizer with z gcd rotate and cut result:")
  ```

  ```pip install channelizer```

  Or clone code


pkgId: 24ab85b79d266fa5095dc5fbd9ff9edc99686eabbac693e4c863e27befc4f513
name: python-channels
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Brings async, event-driven capabilities to Django 3.2 and up.
url: http://github.com/django/channels
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channels-4.1.0-1.src.rpm
checksum_type: sha256
description:
  Channels augments Django to bring WebSocket, long-poll HTTP,
  task offloading and other async support to your code, using familiar Django
  design patterns and a flexible underlying framework that lets you not only
  customize behaviours but also write support for your own protocols and needs.
  Documentation, installation and getting started instructions are at
  https://channels.readthedocs.io
  Channels is an official Django Project and as such has a deprecation policy.
  Details about what's deprecated or pending deprecation for each release is in
  the `release notes <https://channels.readthedocs.io/en/latest/releases/index.html>`_.
  Support can be obtained through several locations - see our
  `support docs <https://channels.readthedocs.io/en/latest/support.html>`_ for more.
  You can install channels from PyPI as the ``channels`` package.
  See our `installation <https://channels.readthedocs.io/en/latest/installation.html>`_
  and `tutorial <https://channels.readthedocs.io/en/latest/tutorial/index.html>`_ docs for more.


pkgId: 907d8eb339c8b77480617d10507a3ac2f2221b637217c2d755d9432d9fd4913c
name: python-channels-auth-token-middlewares
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Django Channels auth token middlewares
url: https://github.com/YegorDB/django-channels-auth-token-middlewares
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channels-auth-token-middlewares-1.1.0-1.src.rpm
checksum_type: sha256
description:
  > Provides Django REST framework [token authentication](https://www.django-rest-framework.org/api-guide/authentication/#tokenauthentication) middleware, [Simple JWT](https://django-rest-framework-simplejwt.readthedocs.io/en/latest/index.html) middleware and easily extendable middlewares to work with auth tokens placed in request headers, cookie and query string.



  - Python>=3.6
  - Channels>=3



  1. `$ pip install channels-auth-token-middlewares`
  2. Add app name to `INSTALLED_APPS`
  ```python
  INSTALLED_APPS = [
      
      
      'channels_auth_token_middlewares',
      
  ]
  ```


  [Explore](tutorial)



  [Explore](docs)





  - Docker>=19
  - docker-compose>=1.25




  `$ docker-compose -f docker-compose.tests.yml up`


  `$ docker-compose -f docker-compose.tests.yml down`


pkgId: 3ab9d52c7e427ffaf2cc92bbd40b35538492432604ec5210db1584588ec0bc54
name: python-channels-binding
arch: src
version: 1.9.8
epoch: 0
release: 1
summary: a RESTful API Streaming system over django channels, with model binding automations
url: https://github.com/workon-io/channels-binding
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channels-binding-1.9.8-1.src.rpm
checksum_type: sha256
description:
  Channels Binding exposes an JSON API streaming system over `channels <https://github.com/django/channels>`_,
  It's designed to work as a full featured RestAPI via websocket, http, or both protocols combined.
  in very few code lines, with a very simple and verboseless exchange structure,
  where each django Models would be easily binded and come with native basics operations like 'retrieve', 'search', 'update', 'create', 'delete' and subscription.
  We could made the comparaison with django restframework with the REST system.
  It also provides react packages with ready-to-use pre configured tools and components to make easy Applications UIs.
  Channels-binding is a compilation of somes packages :
  - https://pypi.org/project/channels-binding/ for python/django
  - https://www.npmjs.com/package/@channels-binding/core for node/react
  - https://www.npmjs.com/package/@channels-binding/mui for material-ui integration


pkgId: 97a59c6fffa3e19ecc761056001991fb3cdf5b793da7d6e1f656764962f3f089
name: python-channels-postgres
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: PostgreSQL-backed ASGI channel layer implementation
url: http://github.com/danidee10/channels_postgres/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channels-postgres-1.0.5-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/danidee10/channels_postgres/actions/workflows/tests.yml/badge.svg)](https://github.com/danidee10/channels_postgres/actions/workflows/tests.yml) [![channels_postgres pypi](https://img.shields.io/pypi/v/channels_postgres.svg)](https://pypi.python.org/pypi/channels_postgres)


  A Django Channels channel layer that uses PostgreSQL as its backing store



  ```bash
  pip install channels_postgres
  ```



  ```python
  INSTALLED_APPS = (
      ...
      'channels',
      'channels_postgres',
      ...
  )
  ```


  ```bash
  python manage.py migrate channels_postgres
  ```



  Add the 'channels_postgres' entry to the DATABASES dictionary in your Django settings file like so:

  ```python
  DATABASES = {
  	'default': {
  		...
  	},
  	'channels_postgres': {
  		'ENGINE': 'django.db.backends.postgresql_psycopg2',
  		'NAME': 'postgres',
  		'USER': 'postgres',
  		'PASSWORD': 'password',
  		'HOST': '127.0.0.1',
  		'PORT': '5432',
  	}
  }
  ```



  Set up the channel layer in your Django settings file like so:

  ```python
  CHANNEL_LAYERS = {
      'default': {
          'BACKEND': 'channels_postgres.core.PostgresChannelLayer',
          'CONFIG': {
              'ENGINE': 'django.db.backends.postgresql_psycopg2',
              'NAME': 'postgres',
              'USER': 'postgres',
              'PASSWORD': 'password',
              'HOST': '127.0.0.1',
              'PORT': '5432',

              'config: {
                  ...
              }
          },
      },
  }
  ```

  The Config object is exactly the same as the standard config object for Django's PostgreSQL database. See the django documentation for more information.

  `config` is a dictionary of parameters to the underlying async postgres library (in this case `aiopg`) This setting can be used to control the database pool size, connection timeout etc. See the [aiopg documentation](https://aiopg.readthedocs.io/en/stable/core.html?highlight=pool#pool) for more information.

  A typical use of `config` would be to increase the `maxsize` of the connection pool. The default of 10 might be too low for sites with a decent amount of traffic.

  The config parameters are described below:



  Prefix to add to all database group keys. Defaults to asgi:. In most cases, you don't need to change this setting because it's only used internally.



  Message expiry in seconds. Defaults to 60. You generally shouldn't need to change this, but you may want to turn it down if you have peaky traffic you wish to drop, or up if you have peaky traffic you want to backlog until you get to it.
  group_expiry



  Defaults to 0.

  `0 means disabled!`

  Channels will be removed from the group after this amount of time; it's recommended you reduce it for a healthier system that encourages disconnections. This value should not be lower than the relevant timeouts in the interface server (e.g. the --websocket_timeout to daphne).
  capacity



  Pass this to enable the optional symmetric encryption mode of the backend. To use it, make sure you have the cryptography package installed, or specify the cryptography extra when you install channels_postgres:

  pip install channels_postgres[cryptography]

  symmetric_encryption_keys should be a list of strings, with each string being an encryption key. The first key is always used for encryption; all are considered for decryption, so you can rotate keys without downtime - just add a new key at the start and move the old one down, then remove the old one after the message expiry time has passed.

  Data is encrypted both on the wire and at rest in Postgres, though we advise you also route your Postgres connections over TLS for higher security.

  Keys should have at least 32 bytes of entropy - they are passed through the SHA256 hash function before being used as an encryption key. Any string will work, but the shorter the string, the easier the encryption is to break.

  If you're using Django, you may also wish to set this to your site's SECRET_KEY setting via the CHANNEL_LAYERS setting:

  ```python
  CHANNEL_LAYERS = {
      'default': {
          'BACKEND': 'channels_postgres.core.PostgresChannelLayer',
          'CONFIG': {
              ...,
              'symmetric_encryption_keys': [SECRET_KEY],
          },
      },
  }
  ```





  Defaults to 0 (which means disabled). This option is tied too closely to `daphne` (The official ASGI interface server for `django-channels`). It makes no sense if you're using an alternate `ASGI` server (like `Uvicorn`) which doesn't disconnect WebSockets automatically.

  Setting it to a non zero value enables the expected behaviour.



  RDMS' like `PostgreSQL` were specifically built to handle huge amounts of data without crashing down and using too much memory. Hence, there's no channel capacity.

  Your database should be able to handle thousands of messages with ease. If you're still worried about the database table growing out of hand, you can reduce the `expiry` time of the individual messages so they will be purged if a consumer cannot process them on time.



  Python >= 3.6 is required for `channels_postgres`


pkgId: 64fdad4594795bb667965d858067b72db8c27d630994e6b8dce7f62e685fa86d
name: python-channels-rabbitmq
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: RabbitMQ-based ASGI channel layer implementation
url: https://pypi.org/project/channels-rabbitmq/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channels-rabbitmq-4.0.1-1.src.rpm
checksum_type: sha256
description:
  A Django Channels channel layer that uses RabbitMQ as its backing store.
  Does not support `Worker and Background Tasks
  <https://channels.readthedocs.io/en/stable/topics/worker.html>`_.
  (See `Rationale
  <https://github.com/CJWorkbench/channels_rabbitmq/pull/11#issuecomment-499185070>`_
  and use ``await get_channel_layer().current_connection`` to send to job queues.)
  Works with Python 3.8 or 3.9.


pkgId: 4ad6b755e5edc27937312cb31efa1be351d20abf4dc372b1367557751d240452
name: python-channels-redis
arch: src
version: 4.2.0
epoch: 0
release: 1
summary: Redis-backed ASGI channel layer implementation
url: http://github.com/django/channels_redis/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channels-redis-4.2.0-1.src.rpm
checksum_type: sha256
description:
  Provides Django Channels channel layers that use Redis as a backing store.
  There are two available implementations:
  * ``RedisChannelLayer`` is the original layer, and implements channel and group
    handling itself.
  * ``RedisPubSubChannelLayer`` is newer and leverages Redis Pub/Sub for message
    dispatch. This layer is currently at *Beta* status, meaning it may be subject
    to breaking changes whilst it matures.
  Both layers support a single-server and sharded configurations.
  `channels_redis` is tested against Python 3.8 to 3.12, `redis-py` versions 4.6,
  5.0, and the development branch, and Channels versions 3, 4 and the development
  branch there.


pkgId: 9d280cf99564b9c542097ca70703cc44e8d715d9eed3a33d05caf62541db23f5
name: python-channelstream
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Websocket server supporting channels/users communication
url: https://github.com/Channelstream/channelstream
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-channelstream-0.7.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status]](https://travis-ci.org/Channelstream/channelstream)

  This is a websocket-based real-time communication server,
  your applications communicate with it via simple JSON REST API.

  Visit http://channelstream.org for more information.



  Obtain source from github and do:

      YOUR_PYTHON_ENV/bin/pip install channelstream

  Generate new configuration:

      YOUR_PYTHON_ENV/bin/channelstream_utils make_config -o config.ini

  Start the server:

      YOUR_PYTHON_ENV/bin/channelstream -i config.ini




  Demo applications live in https://github.com/Channelstream/channelstream_demos repository.

  They show common patterns used in real-time applications.



  Channelstream provides API explorer that you can use to interact with various
  endpoints, it is available by default under http://127.0.0.1:8000/api-explorer.

  To send information client interacts only with your normal www application.
  Your app handled authentication and processing messages from client, then passed
  them as signed message to channelstream server for broadcast.

  websocket client -> webapp (security and transformation happens here) -> REST call to socket server -> broadcast to other clients

  This model is easy to implement, secure, easy to scale and allows all kind of
  languages/apps/work queues to interact with socket server.

  All messages need to be signed with a HMAC of destination endpoint ::

      import requests
      from itsdangerous import TimestampSigner
      signer = TimestampSigner(SERVER_SECRET)
      sig_for_server = signer.sign('/connect')
      secret_headers = {'x-channelstream-secret': sig_for_server,
                        'Content-Type': 'application/json'}
      response = requests.post(url, data=json.dumps(payload),
                               headers=secret_headers).json()



  Please consult API Explorer (http://127.0.0.1:8000/api-explorer) for in depth information
  about endpoints.

  Some examples:

  * /connect **POST** connects users to the server
  * /subscribe **POST** Subscribes connection to new channels
  * /unsubscribe **POST** Removes connection from channels
  * /user_state **POST** set the state of specific user
  * /message **POST** Send message to channels and/or users
  * /message **DELETE** Delete message from history and emit changes
  * /message **PATCH** Edit existing message in history and emit changes
  * /channel_config **POST** Set channel configuration
  * /info **POST** Returns channel information

  Client API

  * /ws **GET** Handles websocket connections
  * /listen **GET** Handles long polling connections
  * /disconnect **GET** Permanently remove connection from server
  * /disconnect **POST** Permanently remove connection from server


  Admin API

  * /admin/admin.json **GET** Return server information in json format for admin panel purposes
  * /admin/admin.json **POST** Return server information in json format for admin panel purposes



  Responses to client are in form of **list** containing **objects**:

  examples:

  **new message** ::

      {
      "date": "2011-09-15T11:36:18.471862",
      "message": MSG_PAYLOAD,
      "type": "message",
      "user": "NAME_OF_POSTER",
      "channel": "CHAN_NAME"
      }

  **presence info** ::

      {
      "date": "2011-09-15T11:43:47.434905",
      "message": {"action":"joined/parted"},
      "type": "presence",
      "user": "NAME_OF_POSTER",
      "channel": "CHAN_NAME"
      }

  Currently following message types are emited: `message`, `message:edit`,
  `message:delete`, `presence`, `user_state_change`.

  [Build Status]: https://travis-ci.org/Channelstream/channelstream.svg?branch=master


pkgId: 88e5ad3f2497e7890f81f458f1de22a5e5aa05c40b58062b33765c43aed44c3f
name: python-chaosdb
arch: src
version: 0.2.12
epoch: 0
release: 1
summary: A Chaostoolkit control to store events on a time series datastore or Grafana
url: https://github.com/sky-uk/chaostoolkit-storeevent
rpm_license: Revised BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaosdb-0.2.12-1.src.rpm
checksum_type: sha256
description:
  This control allows you to store events on a configurable data store.
  The data store can then be used to monitor events on a monitoring dashboard
  or to collect events on a time series datastore.
  The control currently implements the following drivers:

  * an influx driver to store events on a InfluxDB time series database
  * a grafana driver to store events on a Grafana server as annotations

  The grafana driver supports the following authentication types:
  - basic auth (username/password)
  - bearer API token

  To understand what a chaos-toolkit control is please refer to the official
  documentation on [controls](https://docs.chaostoolkit.org/reference/api/experiment/#controls).



  InfluxDB is one of the most used time series data stores, it's implemented in
  golang and therefore is pretty fast and very easy to install and set up.
  Moreover, if you use Gatling for your performance input load simulations, it is
  pretty simple to store Gatling metrics on InfluxDB as well (as the Influx server can be
  configured to accept data in the graphite protocol), so you can use the
  same Influx data store for Gatling metrics and chaos toolkit events.

  You can configure the Influx driver setting these parameters in the
  configuration section (the values provided represent the defaults):

  ```
      "configuration": {
        "influxdb": {
          "host": "localhost",
          "port": 8086,
          "http_endpoint": "/write",
          "database": "gatlingdb"
        }
      }
  ```

  Then, at the proper level, configure the control driver:

  ```
              "controls": [
                  {
                      "name": "tracing",
                      "provider": {
                          "type": "python",
                          "module": "chaosdb.influx"
                      }
                  }
              ],
  ```



  The Grafana driver can be quite convenient if you use grafana for your
  dashboards. The driver sends chaos-toolkit events directly to Grafana using
  the Annotation HTTP API.
  Moreover it is able to draw a region annotation around the whole experiment,
  making experiment visualization more visible.


  The grafana configuration section is keyed `"grafana"`.
  The grafana driver accepts a list of configuration sections, one for each
  grafana server you want to send annotations to.
  Each section accepts the following configuration attributes:

  |Attribute|Description|
  |---------|-----------|
  |host              | the grafana server fqdn|
  |port              | the grafana service port|
  |protocol          | http/https (defaults to http if not set)|
  |api_token         | grafana API token (not mandatory)|
  |cert_file         | file where the TSL certificate is stored (not mandatory)|
  |username          | the simple auth user name (not mandatory)|
  |password          | the simple auth password (not mandatory)|
  |dashboardId       | a specific dashboard ID (all in case it's not specified or 0)|
  |only_actions      | a boolean flag to send only actions or probes as well (defaults to false)|
  |tags              | a list of custom tags to tag annotations|
  annotation_api_endpoint| defaults to '/api/annotations'|

  The 'dashboardId' parameter points to the dashboard annotations are added to,
  otherwise annotations will be displayed on all dashboards.

  The 'only_actions' parameter allows to trace only actions, not probes.
  The 'tags' parameter allows to add custom tags to each annotation.

  Then, at the proper level, configure the control driver:

  ```
              "controls": [
                  {
                      "name": "tracing",
                      "provider": {
                          "type": "python",
                          "module": "chaosdb.grafana"
                      }
                  }
              ],
  ```


pkgId: 57661b6cab76792be0862c4db88c7a3452b331194ffade191e689a827003f891
name: python-chaosmagpy
arch: src
version: 0.14
epoch: 0
release: 1
summary: Evaluates the CHAOS geomagnetic field model and other models of Earth's magnetic field.
url: https://github.com/ancklo/ChaosMagPy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaosmagpy-0.14-1.src.rpm
checksum_type: sha256
description:
  ChaosMagPy is a simple Python package for evaluating the CHAOS geomagnetic
  field model and other models of Earth's magnetic field. The latest CHAOS model
  is available at http://www.spacecenter.dk/files/magnetic-models/CHAOS-7/. To
  quickly get started, download the complete working example including the latest
  model under the "Forward code" section.

rpm_license:
  License =======  All ChaosMagPy source code and documentation is Copyright (C) Clemens Kloss and, unless explicitly stated, licensed under the MIT license.  The exception is with regard to some of the stand-alone example scripts in the ChaosMagPy documentation gallery, which are licensed under the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This is explicitly stated in the header of these example scripts.  MIT License -----------  Copyright (C) 2024 Clemens Kloss.  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: 5cb2f446b8a06c05da0dade01f057d0eef860efd5a554faa8a94782bea964da3
name: python-chaospy
arch: src
version: 4.3.17
epoch: 0
release: 1
summary: Numerical tool for performing uncertainty quantification
url: https://pypi.org/project/chaospy/
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaospy-4.3.17-1.src.rpm
checksum_type: sha256
description:
  Installation is straightforward via `pip <https://pypi.org/>`_:
      pip install chaospy
  Alternatively, if you prefer `Conda <https://conda.io/>`_:
      conda install -c conda-forge chaospy
  After installation, visit the `documentation
  <https://chaospy.readthedocs.io/en/master>`_ to learn how to use the
  toolbox.


pkgId: 82023eee4e7180194e9d30a8a7cae39b86557842620fdeef1acee6d667264685
name: python-chaostoolkit-aws
arch: src
version: 0.35.1
epoch: 0
release: 1
summary: AWS extension for the Chaos Toolkit
url: https://chaostoolkit.org/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaostoolkit-aws-0.35.1-1.src.rpm
checksum_type: sha256
description:
  Welcome to the Amazon Web Services (AWS) extension for Chaos Toolkit. The
  package aggregates activities to target your AWS infrastructure and explore
  your resilience via Chaos Engineering experiments.

  This package requires Python 3.8+
  To be used from your experiment, this package must be installed in the Python
  environment where [chaostoolkit][] already lives.
  ```
  $ pip install -U chaostoolkit-aws
  ```

  To use the probes and actions from this package, add the following to your
  experiment file:
  ```json
  {
      "name": "stop-an-ec2-instance",
      "provider": {
          "type": "python",
          "module": "chaosaws.ec2.actions",
          "func": "stop_instance",
          "arguments": {
              "instance_id": "i-123456"
          }
      }
  },
  {
      "name": "create-a-new-policy",
      "provider": {
          "type": "python",
          "module": "chaosaws.iam.actions",
          "func": "create_policy",
          "arguments": {
              "name": "mypolicy",
              "path": "user/Jane",
              "policy": {
                  "Version": "2012-10-17",
                  "Statement": [
                      {
                          "Effect": "Allow",
                          "Action": [
                              "s3:ListAllMyBuckets",
                              "s3:GetBucketLocation"
                          ],
                          "Resource": "arn:aws:s3:::*"
                      }
                  ]
              }
          }
      }
  }
  ```
  Or select one at random from an AZ:
  ```json
  {
      "name": "stop-an-ec2-instance-in-az-at-random",
      "provider": {
          "type": "python",
          "module": "chaosaws.ec2.actions",
          "func": "stop_instance",
          "arguments": {
              "az": "us-west-1"
          }
      }
  }
  ```
  That's it!
  Please explore the code to see existing probes and actions.


  This extension uses the [boto3][] library under the hood. This library expects
  that you have properly [configured][creds] your environment to connect and
  authenticate with the AWS services.
  [boto3]: https://boto3.readthedocs.io
  [creds]: https://boto3.readthedocs.io/en/latest/guide/configuration.html

  This is the most basic case, assuming your `default` profile is properly
  [configured][default] in `~/.aws/credentials` (or `~/.aws/config`),
  then you do not need to pass any specific credentials to the experiment.
  [default]: https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#shared-credentials-file

  Assuming you have configure a profile in your `~/.aws/credentials`
  (or `~/.aws/config`) file, you may declare it in your experiment as follows:
  ```json
  {
      "configuration": {
          "aws_profile_name": "dev"
      }
  }
  ```
  Your `~/.aws/credentials` should look like this:
  ```
  [dev]
  aws_access_key_id = XYZ
  aws_secret_access_key = UIOPIY
  ```
  Or, your `~/.aws/config` should look like this:
  ```
  [profile dev]
  output = json
  aws_access_key_id = XYZ
  aws_secret_access_key = UIOPIY
  ```

  Assuming you have configure a profile in your `~/.aws/config` file with
  a specific [ARN role][role] you want to assume during the run:
  [role]: https://boto3.readthedocs.io/en/latest/guide/configuration.html#aws-config-file
  ```json
  {
      "configuration": {
          "aws_profile_name": "dev"
      }
  }
  ```
  Your `~/.aws/config` should look like this:
  ```
  [default]
  output = json
  [profile dev]
  role_arn = arn:aws:iam::XXXXXXX:role/role-name
  source_profile = default
  ```

  You mays also assume a role by declaring the role ARN in the experiment
  directly. In that case, the profile has no impact if you also set it.
  ```json
      "configuration": {
          "aws_assume_role_arn": "arn:aws:iam::XXXXXXX:role/role-name",
          "aws_assume_role_session_name": "my-chaos"
      }
  ```
  The `aws_assume_role_session_name` key is optional and will be set to
  `"ChaosToolkit"` when not provided.
  When this approach is used, the extension performs a [assume role][assumerole]
  call against the [AWS STS][sts] service to fetch credentials dynamically.
  [assumerole]: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sts.html#STS.Client.assume_role
  [sts]: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html

  You can pass the credentials as a secret to the experiment definition as
  follows:
  ```json
  {
      "secrets": {
          "aws": {
              "aws_access_key_id": "your key",
              "aws_secret_access_key": "access key",
              "aws_session_token": "token",
          }
      }
  }
  ```
  Note that the token is optional.
  Then, use it as follows:
  ```json
  {
      "name": "stop-an-ec2-instance",
      "provider": {
          "type": "python",
          "module": "chaosaws.ec2.actions",
          "func": "stop_instance",
          "secrets": ["aws"],
          "arguments": {
              "instance_id": "i-123456"
          }
      }
  }
  ```
  [sources]: https://boto3.readthedocs.io/en/latest/guide/configuration.html#configuring-credentials

  In additon to the authentication credentials, you must configure the region
  against which you want to use.
  You can either declare it at the top level of the experiment, add:
  ```json
  {
      "configuration": {
          "aws_region": "us-east-1"
      }
  }
  ```
  or
  ```json
  {
      "configuration": {
          "aws_region": {
              "type": "env",
              "key": "AWS_REGION"
          }
      }
  }
  ```
  But you can also simply set either `AWS_REGION` or `AWS_DEFAULT_REGION` in
  your terminal session without declaring anything in the experiment.
  If none of these are set, your experiment will likely fail.

  If you wish to contribute more functions to this package, you are more than
  welcome to do so. Please, fork this project, write unit tests to cover the proposed changes,
  implement the changes, ensure they meet the formatting standards by running
  `pdm run format` and `pdm run lint`.
  The Chaos Toolkit projects require all contributors must sign a
  [Developer Certificate of Origin][dco] on each commit they would like to merge
  into the master branch of the repository. Please, make sure you can abide by
  the rules of the DCO before submitting a PR.
  [dco]: https://github.com/probot/dco#how-it-works

  If you wish to develop on this project, make sure to install the development
  dependencies. First installk [PDM](https://pdm-project.org/latest/).
  ```console
  $ pdm install --dev
  ```
  Now, you can edit the files and they will be automatically be seen by your
  environment, even when running from the `chaos` command locally.

  To run the tests for the project execute the following:
  ```console
  $ pdm run test
  ```

  We use [ruff][ruff] to lint and format the code.
  [ruff]: https://github.com/astral-sh/ruff
  Before raising a Pull Request, we recommend you run formatting against your code with:
  ```console
  $ pdm run format
  ```
  This will automatically format any code that doesn't adhere to the formatting standards.
  As some things are not picked up by the formatting, we also recommend you run:
  ```console
  $ pdm run lint
  ```
  To ensure that any unused import statements/strings that are too long, etc. are also picked up.

  Once you have setup your environment, you can start adding new
  [AWS API support][awsapi] by adding new actions, probes and entire sub-packages
  for those.
  [awsapi]: https://boto3.readthedocs.io/en/latest/reference/services/index.html

  This package relies on [boto3][] to wrap the API calls into a fluent Python
  API. Some newer AWS services are not yet available in boto3, in that case,
  you should read the next section.
  [boto3]: https://boto3.readthedocs.io/en/latest/reference/services/index.html
  Let's say you want to support a new action in the EC2 sub-package.
  Start by creating a new function in `ec2/actions.py`:
  ```python
  from chaoslib.types import Configuration, Secrets
  from chaosaws import aws_client
  from chaosaws.types import AWSResponse
  def reboot_instance(instance_id: str, dry_run: bool=False,
                      configuration: Configuration=None,
                      secrets: Secrets=None) -> AWSResponse:
      """
      Reboot a given EC2 instance.
      """
      client = aws_client('ec2', configuration, secrets)
      return client.reboot_instances(InstanceIds=[instance_id], DryRun=dry_run)
  ```
  As you can see, the actual code is straightforward. You first create a
  [EC2 client][ec2client] and simply call the appropriate method on that client
  with the expected arguments. We return the action as-is so that it can be
  logged by the chaostoolkit, or even be used as part of a steady-state
  hypothesis probe (if this was a probe, not action that is).
  You could decide to make more than one AWS API call but, it is better to keep
  it simple so that composition is easier from the experiment. Nonetheless,
  you may also compose those directly into a single action as well for specific
  use-cases.
  Please refer to the Chaos Toolkit documentation to learn more about the
  [configuration][] and [secrets][] objects.
  [ec2client]: https://boto3.readthedocs.io/en/latest/reference/services/ec2.html#client
  [configuration]: http://chaostoolkit.org/reference/api/experiment/#configuration
  [secrets]: http://chaostoolkit.org/reference/api/experiment/#secrets
  Once you have implemented that action, you must create at least one unit test
  for it in the `tests/ec2/test_ec2_actions.py` test module. For example:
  ```python
  from chaosaws.ec2.actions import reboot_instancex
  @patch('chaosaws.ec2.actions.aws_client', autospec=True)
  def test_reboot_instance(aws_client):
      client = MagicMock()
      aws_client.return_value = client
      inst_id = "i-1234567890abcdef0"
      response = reboot_instance(inst_id)
      client.reboot_instances.assert_called_with(
          InstanceIds=[inst_id], DryRun=False)
  ```
  By using the [built-in Python module to mock objects][pymock], we can mock the
  EC2 client and assert that we do indeed call the appropriate method with the right
  arguments. You are encouraged to write more than a single test for various
  conditions.
  [pymock]: https://docs.python.org/3/library/unittest.mock.html#module-unittest.mock
  Finally, should you choose to add support for a new AWS API resource altogether,
  you should create the according sub-package.

  If the support you want to provide is for a new AWS service that [boto][] does
  not support yet, this requires direct call to the API endpoint via the
  [requests][] package. Say we have a new service, not yet supported by boto3
  [eks]: https://aws.amazon.com/eks/
  [boto]: https://boto3.readthedocs.io/en/latest/index.html
  [requests]: http://docs.python-requests.org/en/master/
  ```python
  from chaoslib.types import Configuration, Secrets
  from chaosaws import signed_api_call
  from chaosaws.types import AWSResponse
  def terminate_worker_node(worker_node_id: str,
                            configuration: Configuration=None,
                            secrets: Secrets=None) -> AWSResponse:
      """
      Terminate a worker node.
      """
      params = {
          "DryRun": True,
          "WorkerNodeId.1": worker_node_id
      }
      response = signed_api_call(
          'some-new-service-name', path='/2018-01-01/worker/terminate',
          method='POST', params=params,
          configuration=configuration, secrets=secrets)
      return response.json()
  ```
  Here is an example on existing API call (as a more concrete snippet):
  ```python
  from chaoslib.types import Configuration, Secrets
  from chaosaws import signed_api_call
  def stop_instance(instance_id: str, configuration: Configuration=None,
                    secrets: Secrets=None) -> str:
      response = signed_api_call(
          'ec2',
          configuration=configuration,
          secrets=secrets,
          params={
              "Action": "StopInstances",
              "InstanceId.1": instance_id,
              "Version": "2013-06-15"
          }
      )
      
      return response.text
  ```
  When using the `signed_api_call`, you are responsible for the right way of
  passing the parameters. Basically, look at the AWS documentation for each
  API call.
  **WARNING:** It should be noted that, whenever boto3 implements an API, this
  package should be updated accordingly, as boto3 is much more versatile and
  solid.

  Finally, if you have created a new sub-package entirely, you need to make its
  capability discoverable by the chaos toolkit. Simply amend the `discover`
  function in the `chaosaws/__init__.py`. For example, assuming a new `eks`
  sub-package, with actions and probes:
  ```python
      activities.extend(discover_actions("chaosaws.eks.actions"))
      activities.extend(discover_probes("chaosaws.eks.probes"))
  ```


pkgId: 4cacc7d7743f993ea2f5b6d0d260a453170616ffc2cbeafac8c0bb60b559bd9d
name: python-chaostoolkit-k6
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Chaos Toolkit Extension for k6.
url: http://chaostoolkit.org
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaostoolkit-k6-0.3.4-1.src.rpm
checksum_type: sha256
description:
  [![Python versions](https://img.shields.io/pypi/pyversions/chaostoolkit-k6.svg)](https://www.python.org/)

  This project is a collection of [actions][] and [probes][], gathered as an
  extension to the [Chaos Toolkit][chaostoolkit].

  [actions]: http://chaostoolkit.org/reference/api/experiment/#action
  [probes]: http://chaostoolkit.org/reference/api/experiment/#probe
  [chaostoolkit]: http://chaostoolkit.org



  This package requires Python 3.5+

  To be used from your experiment, this package must be installed in the Python
  environment where [chaostoolkit][] already lives.

  ```
  $ pip install -U chaostoolkit-k6
  ```



  Please explore the code to see existing probes and actions.




  If you wish to contribute more functions to this package, you are more than
  welcome to do so. Please, fork this project, make your changes following the
  usual [PEP 8][pep8] code style, sprinkling with tests and submit a PR for
  review.

  [pep8]: https://pycodestyle.readthedocs.io/en/latest/

  The Chaos Toolkit projects require all contributors must sign a
  [Developer Certificate of Origin][dco] on each commit they would like to merge
  into the master branch of the repository. Please, make sure you can abide by
  the rules of the DCO before submitting a PR.

  [dco]: https://github.com/probot/dco#how-it-works



  If you wish to develop on this project, make sure to install the development
  dependencies. But first, [create a virtual environment][venv] and then install
  those dependencies.

  [venv]: http://chaostoolkit.org/reference/usage/install/#create-a-virtual-environment

  ```console
  $ pip install -r requirements-dev.txt -r requirements.txt
  ```

  Then, point your environment to this directory:

  ```console
  $ pip install -e .
  ```

  Now, you can edit the files and they will be automatically be seen by your
  environment, even when running from the `chaos` command locally.



  To run the tests for the project execute the following:

  ```
  $ pytest
  ```


pkgId: be3b9809f2ac18b1befa2be7f29955fce1c9d02e1617cd66352714abcb97516a
name: python-chaostoolkit-kubernetes
arch: src
version: 0.39.0
epoch: 0
release: 1
summary: Chaos Toolkit Extension for Kubernetes
url: https://pypi.org/project/chaostoolkit-kubernetes/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaostoolkit-kubernetes-0.39.0-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/chaostoolkit/chaostoolkit-kubernetes/actions/workflows/build.yaml/badge.svg)](https://github.com/chaostoolkit/chaostoolkit-kubernetes/actions/workflows/build.yaml)
  [![Python versions](https://img.shields.io/pypi/pyversions/chaostoolkit-kubernetes.svg)](https://www.python.org/)
  [![Downloads](https://pepy.tech/badge/chaostoolkit-kubernetes)](https://pepy.tech/project/chaostoolkit-kubernetes)

  This project contains activities, such as probes and actions, you can call from
  your experiment through the Chaos Toolkit to perform Chaos Engineering against
  the Kubernetes API: killing a pod, removing a statefulset or node...



  To be used from your experiment, this package must be installed in the Python
  environment where [chaostoolkit][] already lives.

  [chaostoolkit]: https://github.com/chaostoolkit/chaostoolkit

  ```
  $ pip install chaostoolkit-kubernetes
  ```



  To use the probes and actions from this package, add the following to your
  experiment file:

  ```json
  {
      "title": "Do we remain available in face of pod going down?",
      "description": "We expect Kubernetes to handle the situation gracefully when a pod goes down",
      "tags": ["kubernetes"],
      "steady-state-hypothesis": {
          "title": "Verifying service remains healthy",
          "probes": [
              {
                  "name": "all-our-microservices-should-be-healthy",
                  "type": "probe",
                  "tolerance": true,
                  "provider": {
                      "type": "python",
                      "module": "chaosk8s.probes",
                      "func": "microservice_available_and_healthy",
                      "arguments": {
                          "name": "myapp"
                      }
                  }
              }
          ]
      },
      "method": [
          {
              "type": "action",
              "name": "terminate-db-pod",
              "provider": {
                  "type": "python",
                  "module": "chaosk8s.pod.actions",
                  "func": "terminate_pods",
                  "arguments": {
                      "label_selector": "app=my-app",
                      "name_pattern": "my-app-[0-9]$",
                      "rand": true
                  }
              },
              "pauses": {
                  "after": 5
              }
          }
      ]
  }
  ```

  That's it! Notice how the action gives you the way to kill one pod randomly.

  Please explore the [documentation][doc] to see existing probes and actions.

  [doc]: https://chaostoolkit.org/drivers/kubernetes/#exported-activities



  Note, for the network, cpu and memory stressors we rely on the fantastic
  [Chaos Mesh project](https://chaos-mesh.org/) that provides a great interface
  to inject these faults.

  You will need to install Chaos Mesh first in your cluster to use them.





  If you have a valid entry in your `~/.kube/config` file for the cluster you
  want to target, then there is nothing to be done.

  You may specify `KUBECONFIG` to specify a different location.

  ```
  $ export KUBECONFIG=/tmp/my-config
  ```



  Quite often, your Kubernetes configuration contains several entries, and you
  need to define the one to use as a default context when it isn't
  explicitly provided.

  You may of course change your default using
  `kubectl config use-context KUBERNETES_CONTEXT` but you can also be explicit
  in your experiment as follows:

  ```json
  {
      "title": "Do we remain available in face of pod going down?",
      "description": "We expect Kubernetes to handle the situation gracefully when a pod goes down",
      "tags": ["kubernetes"],
      "secrets": {
          "k8s": {
              "KUBERNETES_CONTEXT": "..."
          }
      },
      "steady-state-hypothesis": {
          "title": "Verifying service remains healthy",
          "probes": [
              {
                  "name": "all-our-microservices-should-be-healthy",
                  "type": "probe",
                  "tolerance": true,
                  "secrets": ["k8s"],
                  "provider": {
                      "type": "python",
                      "module": "chaosk8s.probes",
                      "func": "microservice_available_and_healthy",
                      "arguments": {
                          "name": "myapp"
                      }
                  }
              }
          ]
      },
      "method": [
          {
              "type": "action",
              "name": "terminate-db-pod",
              "secrets": ["k8s"],
              "provider": {
                  "type": "python",
                  "module": "chaosk8s.pod.actions",
                  "func": "terminate_pods",
                  "arguments": {
                      "label_selector": "app=my-app",
                      "name_pattern": "my-app-[0-9]$",
                      "rand": true
                  }
              },
              "pauses": {
                  "after": 5
              }
          }
      ]
  }
  ```

  You need to specify the `KUBERNETES_CONTEXT` secret key to the name of the
  context you want the experiment to use. Make sure to also inform the
  actions and probes about the secret entries they should be
  passed `"secrets": ["k8s"]`.



  When running from a pod (not your local machine or a CI for instance), the
   `./.kube/config` file does not exist. Instead, the credentials can be found
   at [/var/run/secrets/kubernetes.io/serviceaccount/token][podcreds].

   [podcreds]: https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#accessing-the-api-from-a-pod

   To let the extension know about this, simply set `CHAOSTOOLKIT_IN_POD` from the
   environment variable of the pod specification:

  ```yaml
  env:
  - name: CHAOSTOOLKIT_IN_POD
    value: "true"
  ```



  Finally, you may pass explicitly all required credentials information to the
  experiment as follows:



  ```json
  {
      "secrets": {
          "kubernetes": {
              "KUBERNETES_HOST": "http://somehost",
              "KUBERNETES_API_KEY": {
                  "type": "env",
                  "key": "SOME_ENV_VAR"
              }
          }
      }
  }
  ```



  ```json
  {
      "secrets": {
          "kubernetes": {
              "KUBERNETES_HOST": "http://somehost",
              "KUBERNETES_USERNAME": {
                  "type": "env",
                  "key": "SOME_ENV_VAR"
              },
              "KUBERNETES_PASSWORD": {
                  "type": "env",
                  "key": "SOME_ENV_VAR"
              }
          }
      }
  }
  ```



  ```json
  {
      "secrets": {
          "kubernetes": {
              "KUBERNETES_HOST": "http://somehost",
              "KUBERNETES_CERT_FILE": {
                  "type": "env",
                  "key": "SOME_ENV_VAR"
              },
              "KUBERNETES_KEY_FILE": {
                  "type": "env",
                  "key": "SOME_ENV_VAR"
              }
          }
      }
  }
  ```



  On some managed Kubernetes clusters, you also need to authenticate against the
  platform itself because the Kubernetes authentication is delegated to it.



  In addition to your Kubernetes credentials (via the `~/.kube/config` file), you
  need to authenticate against the Google Cloud Platform itself. Usually this
  is done [via][gcloud]:

  [gcloud]: https://cloud.google.com/sdk/gcloud/reference/auth/login

  ```
  $ gcloud auth login
  ```

  But can also be achieved by defining the `GOOGLE_APPLICATION_CREDENTIALS`
  environment variable.



  If you wish to contribute more functions to this package, you are more than
  welcome to do so. Please, fork this project, write unit tests to cover the proposed changes,
  implement the changes, ensure they meet the formatting standards and then raise a
  PR to the repository for review.

  Please refer to the [formatting](#formatting-and-linting) section for more information
  on the formatting standards.

  The Chaos Toolkit projects require all contributors must sign a
  [Developer Certificate of Origin][dco] on each commit they would like to merge
  into the master branch of the repository. Please, make sure you can abide by
  the rules of the DCO before submitting a PR.

  [dco]: https://github.com/probot/dco#how-it-works



  If you wish to develop on this project, make sure to install the development
  dependencies. But first, [install PDM][pdm] and then install
  the dependencies.

  [pdm]: https://pdm-project.org/latest/

  ```console
  $ pdm install
  ```

  Now, you can edit the files, and they will be automatically be seen by your
  environment, even when running from the `chaos` command locally.



  To run the tests for the project execute the following:

  ```console
  $ pdm run tests
  ```



  We use [ruff][] to both lint and format this repositories code.

  [ruff]: https://github.com/astral-sh/ruff

  Before raising a Pull Request, we recommend you run formatting against your code with:

  ```console
  $ pdm run format
  ```

  This will automatically format any code that doesn't adhere to the formatting standards.

  As some things are not picked up by the formatting, we also recommend you run:

  ```console
  $ pdm run lint
  ```

  To ensure that any unused import statements/strings that are too long, etc. are also picked up.


pkgId: 4adde428f985b6f4987309f85f0767615a1b53953bed8f056f3a109f7ba18650
name: python-chaostoolkit-reliably
arch: src
version: 0.79.0
epoch: 0
release: 1
summary: Reliably CLI
url: https://pypi.org/project/chaostoolkit-reliably/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaostoolkit-reliably-0.79.0-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/chaostoolkit-reliably.svg)](https://img.shields.io/pypi/v/chaostoolkit-reliably.svg)
  [![Python versions](https://img.shields.io/pypi/pyversions/chaostoolkit-reliably.svg)](https://www.python.org/)
  [![License](https://img.shields.io/pypi/l/chaostoolkit-reliably.svg)](https://img.shields.io/pypi/l/chaostoolkit-reliably.svg)
  [![Build](https://github.com/chaostoolkit-incubator/chaostoolkit-reliably/actions/workflows/build.yaml/badge.svg)](https://github.com/chaostoolkit-incubator/chaostoolkit-reliably/actions/workflows/build.yaml)

  [Chaos Toolkit][chaostoolkit] extension for [Reliably][reliably].

  [reliably]: https://reliably.com
  [chaostoolkit]: http://chaostoolkit.org/



  To be used from your experiment, this package must be installed in the Python
  environment where [chaostoolkit][] already lives.

  [chaostoolkit]: https://github.com/chaostoolkit/chaostoolkit

  ```
  $ pip install chaostoolkit-reliably
  ```



  To use this package, you must create have registered with
  [Reliably services](https://app.reliably.com/).

  Then you need to set some environment variables as secrets.

  * `RELIABLY_TOKEN`: the token to authenticate against Reliably's API
  * `RELIABLY_HOST:`: the hostname to connect to, default to `app.reliably.com`

  ```json
  {
      "secrets": {
          "reliably": {
              "token": {
                  "type": "env",
                  "key": "RELIABLY_TOKEN"
              },
              "host": {
                  "type": "env",
                  "key": "RELIABLY_HOST",
                  "default": "app.reliably.com"
              }
          }
      }
  }
  ```





  This extensions offers a
  [variety of probes and tolerances](https://chaostoolkit.org/drivers/reliably/)
  ready to be used in your steady-state blocks.

  For instance:

  ```json
  {
    "version": "1.0.0",
    "title": "SLO error-count-3h / Error budget 10%",
    "description": "Monitor the health of our demo service from our users perspective and ensure they have a high-quality experience",
    "runtime": {
      "hypothesis": {
        "strategy": "after-method-only"
      }
    },
    "steady-state-hypothesis": {
      "title": "Compute SLO and validate its Error Budget with our target",
      "probes": [
        {
          "type": "probe",
          "name": "get-slo",
          "tolerance": {
            "type": "probe",
            "name": "there-should-be-error-budget-left",
            "provider": {
              "type": "python",
              "module": "chaosreliably.activities.slo.tolerances",
              "func": "has_error_budget_left",
              "arguments": {
                "name": "cloudrun-service-availability"
              }
            }
          },
          "provider": {
            "type": "python",
            "module": "chaosreliably.activities.slo.probes",
            "func": "compute_slo",
            "arguments": {
              "slo": {
                "apiVersion": "sre.google.com/v2",
                "kind": "ServiceLevelObjective",
                "metadata": {
                  "name": "cloudrun-service-availability",
                  "labels": {
                    "service_name": "cloudrun",
                    "feature_name": "service",
                    "slo_name": "availability"
                  }
                },
                "spec": {
                  "description": "Availability of Cloud Run service",
                  "backend": "cloud_monitoring_mql",
                  "method": "good_bad_ratio",
                  "exporters": [

                  ],
                  "service_level_indicator": {
                    "filter_good": "fetch cloud_run_revision | metric 'run.googleapis.com/request_count' | filter resource.project_id == '${CLOUDRUN_PROJECT_ID}' | filter resource.service_name == '${CLOUDRUN_SERVICE_NAME}' | filter metric.response_code_class == '2xx'",
                    "filter_valid": "fetch cloud_run_revision | metric 'run.googleapis.com/request_count' | filter resource.project_id == '${CLOUDRUN_PROJECT_ID}' | filter resource.service_name == '${CLOUDRUN_SERVICE_NAME}'"
                  },
                  "goal": 0.9
                }
              },
              "config": {
                "backends": {
                  "cloud_monitoring_mql": {
                    "project_id": "${STACKDRIVER_HOST_PROJECT_ID}"
                  }
                },
                "error_budget_policies": {
                  "default": {
                    "steps": [
                      {
                        "name": "3 hours",
                        "burn_rate_threshold": 9,
                        "alert": false,
                        "window": 10800,
                        "message_alert": "Page the SRE team to defend the SLO",
                        "message_ok": "Last 3 hours on track"
                      }
                    ]
                  }
                }
              }
            }
          }
        }
      ]
    },
    "method": [
      {
        "name": "inject-traffic-into-endpoint",
        "type": "action",
        "background": true,
        "provider": {
          "func": "inject_gradual_traffic_into_endpoint",
          "type": "python",
          "module": "chaosreliably.activities.load.actions",
          "arguments": {
            "endpoint": "${ENDPOINT}",
            "step_duration": 30,
            "test_duration": 300,
            "step_additional_vu": 3,
            "vu_per_second_rate": 1,
            "results_json_filepath": "./load-test-results.json"
          }
        }
      }
    ]
  }
  ```

  This above example will get the last 5 Objective Results for our `Must be good` SLO and determine if they were all okay or whether we've spent our [error budget](https://sre.google/workbook/error-budget-policy/#:~:text=Error%20budgets%20are%20the%20tool,with%20the%20pace%20of%20innovation.&text=The%20error%20budget%20forms%20a,has%20a%200.1%25%20error%20budget.)
  they are allowed.




  You can use controls provided by `chaostoolkit-reliably` to track your experiments
  within Reliably. The block is inserted automatically by Reliably when you
  import the experiment into Reliably.



  From a code perspective, if you wish to contribute, you will need to run a
  Python 3.6+ environment. Please, fork this project, write unit tests to cover
  the proposed changes, implement the changes, ensure they meet the formatting
  standards set out by `black`, `ruff`, `isort`, and `mypy`, add an entry into
  `CHANGELOG.md`, and then raise a PR to the repository for review

  Please refer to the [formatting](#formatting-and-linting) section for more
  information on the formatting standards.

  The Chaos Toolkit projects require all contributors must sign a
  [Developer Certificate of Origin][dco] on each commit they would like to merge
  into the master branch of the repository. Please, make sure you can abide by
  the rules of the DCO before submitting a PR.

  [dco]: https://github.com/probot/dco#how-it-works



  If you wish to develop on this project, make sure to install the development
  dependencies. First you will need to install globally
  [pdm](https://pdm.fming.dev/latest/) and create a virtual environment:

  ```
  $ pdm create venv
  $ pdm use
  $ $(pdm venv activate)
  ```

  Then install the dependencies:

  ```console
  $ pdm sync -d
  ```



  To run the tests for the project execute the following:

  ```console
  $ pdm run test
  ```



  We use a combination of [`black`][black], [`ruff`][flake8], [`isort`][isort],
  [`mypy`][mypy] and [`bandit`][] to both lint and format this repositories code.

  [black]: https://github.com/psf/black
  [ruff]: https://github.com/charliermarsh/ruff
  [isort]: https://github.com/PyCQA/isort
  [mypy]: https://github.com/python/mypy
  [bandit]: https://bandit.readthedocs.io/en/latest/

  Before raising a Pull Request, we recommend you run formatting against your
  code with:

  ```console
  $ pmd run format
  ```

  This will automatically format any code that doesn't adhere to the formatting
  standards.

  As some things are not picked up by the formatting, we also recommend you run:

  ```console
  $ pdm run lint
  ```

  To ensure that any unused import statements/strings that are too long, etc.
  are also picked up. It will also provide you with any errors `mypy` picks up.


pkgId: 5322ddf7dc90277d3c3f4b370ca79cd563a1f2a0f3e4833555d905f4ab96127b
name: python-chaostoolkit-toxiproxy
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Chaos Toolkit Extension for managing toxiproxy from an experiment
url: http://chaostoolkit.org
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaostoolkit-toxiproxy-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/chaostoolkit-incubator/chaostoolkit-toxiproxy.svg?branch=master)](https://travis-ci.org/chaostoolkit-incubator/chaostoolkit-toxiproxy)
  [![Python versions](https://img.shields.io/pypi/pyversions/chaostoolkit-toxiproxy.svg)](https://www.python.org/)

  Welcome to the [Chaos Toolkit][chaostoolkit] driver for [Toxiproxy][toxiproxy]! This extension allows you to setup toxy proxy probes and methods from chaostoolkit by leveraging the toxyproxy [http management api](https://github.com/Shopify/toxiproxy#http-api).

  [toxiproxy]: https://github.com/Shopify/toxiproxy
  [chaostoolkit]: http://chaostoolkit.org


  1. Install the [Toxiproxy base client](https://github.com/Shopify/toxiproxy/releases)
  2. Install the [Toxiproxy CLI](https://github.com/Shopify/toxiproxy/releases)


  This package requires Python 3.5+

  To be used from your experiment, this package must be installed in the Python
  environment where [chaostoolkit][] already lives.

  ```
  $ pip install -U chaostoolkit-toxiproxy
  ```




  First, run the Toxiproxy base client locally to create a `localhost:8474` host on your computer. Then [create a proxy](https://github.com/Shopify/toxiproxy#2-populating-toxiproxy).

  Next, to start using the actions and probes all you need to do is add the toxiproxy host with "toxiproxy_host" as the key, and optionally the port with "toxiproxy_port" as the key, to the configuration section in your experiment json. If not provided the port defaults to 8474.

  Alternatively, if toxiproxy api is accessible using a reverse proxy, you can use `toxiproxy_url` setting.

  Example using `toxiproxy_host` in experiment.json

  ```json
  "configuration": {
      "toxiproxy_host" : "10.124.23.183",
      "some_environment_variable": {
        "type": "environment",
        "key": "ENVIRONMENT_VARIABLE"
      }
    },
  ```

  Example using `toxiproxy_url` in experiment.json

  ```json
  "configuration": {
      "toxiproxy_url" : "http://mydomain.com:8080/path-to-toxiproxy-api",
      "some_environment_variable": {
        "type": "environment",
        "key": "ENVIRONMENT_VARIABLE"
      }
    },
  ```

  This extension follows the toxiproxy rules. A proxy is the channel where toxicity can be added. For this reason the extension is broken into proxy management and toxic management.

  All actions and probes in the extension are of python type and are used like any other python extension.





  Creates a proxy to which toxics can be added. In toxiproxy a listen port of value 0 tells the API to assign a random available port. The value where the proxy is listenting will be attached to the **chaostoolkit configuration object** as *\<proxyname\>_PORT*. Should the creation of the proxy fail, an assertion error is raised stopping all subsequent actions.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |proxy_name|name for the proxy|Yes|None|
  |upstream_host|ip address of the host to send traffic to|Yes|None|
  |upstream_port|port of the application to send traffic to|Yes|None|
  |listen_host| IP address to bind where toxiproxy listens|No| 0.0.0.0|
  |listen_port|port to listen for requests, 0 means pick random value|No|0|
  |enabled| Whether to start listening or not|No|True|



  Modify the configuration of a given proxy. Useful to change the upstream configiuration. Only arguments supplied result in modification of the proxy.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |proxy_name|name for the proxy|Yes|None|
  |listen_addres|ip:port address to modify|No|None|
  |upstream_addres|ip:port of the upstream|No|None|
  |enabled| Toggle enabled/disabled state|No|None|



  Disables the proxy, this is useful to simulate a proxied service being down.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |proxy_name|name for the proxy to disable|Yes|None|




  Enables a disabled proxy.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |proxy_name|name for the proxy to enable|Yes|None|



  Removes the proxy from the system.

  Example usage

  ```json
   "method": [
        {
              "type": "action",
              "name": "setup_toxiproxy_proxy",
              "provider": {
                  "type": "python",
                  "module": "chaostoxi.proxy.actions",
                  "func": "create_proxy",
                  "arguments": {
                      "proxy_name": "myproxy",
                      "listen_port" : 6666,
                      "upstream_host" : "10.28.188.118",
                      "upstream_port" : 6040
                  }
              },
              "pauses": {
                  "after": 1
              }
          }
        ]
  ```



  Enable all proxies and remove all active toxics.

  Example usage:
  ```json
  "method": [
      {
          "type": "action",
          "name": "reset all proxies",
          "provider": {
              "type": "python",
              "module": "chaostoxi.proxy.actions",
              "func": "reset"
          },
          "pauses": {
              "after": 1
          }
      }
  ]
  ```





  Returns True of False if a given proxy exists.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |proxy_name|name for the proxy|Yes|None|



  All actions provided by this extension match the types and attributes of [toxics](https://github.com/Shopify/toxiproxy#toxics).



  Allows you to create any of the supported types of toxics with their attributes.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|
  |toxic_type|A valid toxic type|Yes|None|
  |stream| The direction of the toxic "upstream" or "downstream"|No|downstream|
  |toxicity|Percentage of toxiciy 1.0 is 100%, 0.5 is 50% etc| No| 1.0|
  |attributes|Dictionary of attributes for the type of toxic|No|None|



  Add a delay to all data going through the proxy using a downstream with a toxicity of 100%.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|
  |latency| time in milliseconds to add for latency| Yes|None|
  |jitter| time in milliseconds to jitter|No|0



  Limit the bandwith of a  downstream connection with a toxicity of 100%.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|
  |rate| desired bandwith rate in KB/s| Yes|None|



  Generate as downstream delayed TCP close with a toxicity of 100%.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|
  |delay| desired close delay in milliseconds| Yes|None|



  Slices TCP data up into small bits, optionally adding a delay between each sliced "packet" with a toxicity of 100%.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|
  |average_size| size in bytes for the average package| Yes|None|
  |size_variation| variation in bytes of an average pkg (should be smaller than average_size)|Yes|None
  |delay| time in microseconds to delay each packet by|Yes|None



  Closes connections when transmitted data after the limit, sets it up as a dowsntream, 100% toxicity.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|
  |bytes| number of bytes to transmit before connection is closed| Yes|None|



  Deletes the a given toxic.

  |Argument|Description|Required|Default|
  |--------|-----------|--------|-------|
  |for_proxy|name for the proxy to attach the toxy|Yes|None|
  |toxic_name|name for this toxy|Yes|None|

  Example usage:

  ```json
   "method": [
        {
              "type": "action",
              "name": "create_latency_toxic",
              "provider": {
                  "type": "python",
                  "module": "toxiproxy.toxic.actions",
                  "func": "create_dowsntream_latency_toxic",
                  "arguments": {
                      "for_proxy": "edsproxy",
                      "toxic_name": "latency_toxic",
                      "latency": 5000,
                      "jitter": 200
                  }
              },
              "pauses": {
                  "after": 1
              }
          }
   ]
  ```



  If you wish to contribute more functions to this package, you are more than
  welcome to do so. Please, fork this project, make your changes following the
  usual [PEP 8][pep8] code style, sprinkling with tests and submit a PR for
  review.

  [pep8]: https://pycodestyle.readthedocs.io/en/latest/

  The Chaos Toolkit projects require all contributors must sign a
  [Developer Certificate of Origin][dco] on each commit they would like to merge
  into the master branch of the repository. Please, make sure you can abide by
  the rules of the DCO before submitting a PR.

  [dco]: https://github.com/probot/dco#how-it-works



  If you wish to develop on this project, make sure to install the development
  dependencies. But first, [create a virtual environment][venv] and then install
  those dependencies.

  [venv]: http://chaostoolkit.org/reference/usage/install/#create-a-virtual-environment

  ```console
  $ pip install -r requirements-dev.txt -r requirements.txt
  ```

  Then, point your environment to this directory:

  ```console
  $ python setup.py develop
  ```

  Now, you can edit the files and they will be automatically be seen by your
  environment, even when running from the `chaos` command locally.



  To run the unit tests for the project execute the following:

  ```
  $ pytest
  ```

  To run the integration tests for the project execute the following:

  ```
  $ tox
  ```


pkgId: 142a76cac58b20b0ebdbd7f8d95600504ebec08621694985a9e1869a9360d090
name: python-char-count-package
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A package to count the ocurrency of unique characters in a string or file.
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-char-count-package-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Create and activate a virtual environment.
  ```
  virtualenv venv
  venv/scripts/activate
  ```

  Install the package:
  ```
  python -m pip install char_count_package
  ```

  Now you can import the package:
  ```
  import char_count_package
  ```



  From your working directory run:
  ```
  python [your_directory.py] --string [your desired string] --filepath [your desired filepath]
  ```

  Or if you want to work with only string, Run:
  ```
  python [your_directory.py] --string [your desired string]
  ```


pkgId: fb989a726cc0a66dff0bb6b032d8c40f6f76da855319d6aa5816ad6a68c9a590
name: python-characterai
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: An unofficial API for Character AI for Python
url: https://github.com/kramcat/characterai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-characterai-1.0.1-1.src.rpm
checksum_type: sha256
description:
  This version of the library is in alpha version, there may be bugs and errors. The library was developed without the participation of Character AI developers or their knowledge. To work with the library you need to know how to work with `asyncio <https://docs.python.org/3/library/asyncio.html>`_


pkgId: 0c189ba5fe39d72742c48f30d250f9b5d5a23cda991c5044e0999c24a0ce413a
name: python-characteristic
arch: src
version: 14.3.0
epoch: 0
release: 1
summary: Python attributes without boilerplate.
url: https://characteristic.readthedocs.org/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-characteristic-14.3.0-1.src.rpm
checksum_type: sha256
description:
  ``characteristic`` is an `MIT <http://choosealicense.com/licenses/mit/>`_-licensed Python package with class decorators that ease the chores of implementing the most common attribute-related object protocols.
  You just specify the attributes to work with and ``characteristic`` gives you any or all of:
  - a nice human-readable ``__repr__``,
  - a complete set of comparison methods,
  - immutability for attributes,
  - and a kwargs-based initializer (that cooperates with your existing one and optionally even checks the types of the arguments)
  *without* writing dull boilerplate code again and again.
  This gives you the power to use actual classes with actual types in your code instead of confusing ``tuple``\ s or confusingly behaving ``namedtuple``\ s.
  So put down that type-less data structures and welcome some class into your life!
  ``characteristic``\ ’s documentation lives at `Read the Docs <https://characteristic.readthedocs.org/>`_, the code on `GitHub <https://github.com/hynek/characteristic>`_.
  It’s rigorously tested on Python 2.6, 2.7, 3.3+, and PyPy.


pkgId: c784b19c3a05affdaa70da3a03cb6a2f41623f276689b9dfe2bb718d1f5a6995
name: python-charade
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Universal encoding detector for python 2 and 3
url: https://github.com/sigmavirus24/charade
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charade-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Detects
   - ASCII, UTF-8, UTF-16 (2 variants), UTF-32 (4 variants)
   - Big5, GB2312, EUC-TW, HZ-GB-2312, ISO-2022-CN (Traditional and Simplified Chinese)
   - EUC-JP, SHIFT_JIS, ISO-2022-JP (Japanese)
   - EUC-KR, ISO-2022-KR (Korean)
   - KOI8-R, MacCyrillic, IBM855, IBM866, ISO-8859-5, windows-1251 (Cyrillic)
   - ISO-8859-2, windows-1250 (Hungarian)
   - ISO-8859-5, windows-1251 (Bulgarian)
   - windows-1252 (English)
   - ISO-8859-7, windows-1253 (Greek)
   - ISO-8859-8, windows-1255 (Visual and Logical Hebrew)
   - TIS-620 (Thai)
  Requires Python 2.6 or later


pkgId: ee179f9f733c4872e494c1129c682cb1d6da4f45e41f447b9205cf4dc854ba76
name: python-chardet2
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Character encoding auto-detection in Python 3
url: https://github.com/byroot/chardet
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chardet2-2.0.3-1.src.rpm
checksum_type: sha256
description:
  Detects
    - ASCII, UTF-8, UTF-16 (2 variants), UTF-32 (4 variants)
    - Big5, GB2312, EUC-TW, HZ-GB-2312, ISO-2022-CN (Traditional and Simplified Chinese)
    - EUC-JP, SHIFT_JIS, ISO-2022-JP (Japanese)
    - EUC-KR, ISO-2022-KR (Korean)
    - KOI8-R, MacCyrillic, IBM855, IBM866, ISO-8859-5, windows-1251 (Cyrillic)
    - ISO-8859-2, windows-1250 (Hungarian)
    - ISO-8859-5, windows-1251 (Bulgarian)
    - windows-1252 (English)
    - ISO-8859-7, windows-1253 (Greek)
    - ISO-8859-8, windows-1255 (Visual and Logical Hebrew)
    - TIS-620 (Thai)
  Requires Python 3 or later


pkgId: 9bb1f4b76cac13ae377bcc5aca999b5c262582d4db3ed8ffcb40096992e123d1
name: python-chargebee-byte
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Chargebee API library. Made by Byte.nl
url: https://github.com/ByteInternet/chargebee-byte
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chargebee-byte-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/ByteInternet/chargebee-byte.svg?branch=master)](https://travis-ci.org/ByteInternet/chargebee-byte)
  [![Latest version on PyPI](https://img.shields.io/pypi/v/chargebee-byte.svg?maxAge=2592000)](https://pypi.org/project/chargebee-byte)
  [![Licence](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

  A Python Chargebee API client library. Written by [Byte.nl](https://www.byte.nl).



      pip install chargebee_byte



  ```python
  import chargebee_byte.client
  client = chargebee_byte.client.Client(site_name, api_key)
  subscriptions = client.get_all_subscriptions()
  ```


pkgId: ebdd087a54a8deabdb7350aa743f28b89cf5ee63830e4a5a7d2d978822444bbc
name: python-charizard-vla
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: VLA data processing package with polarization and self-calibration
url: https://github.com/arpanastrobot/charizard-vla
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charizard-vla-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Charizard-VLA is an automated package for VLA data processing with polarization calibration and self-calibration.



  You can install the package using pip:

  ```bash
  pip install charizard-vla


  charizard-vla config.ini


pkgId: 14312f262c07e2b29eb3884a4827582055047105b8c358bee8bfddf64fbf9a41
name: python-charlatan
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: Efficiently manage and install data fixtures
url: https://github.com/uber/charlatan
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charlatan-0.4.6-1.src.rpm
checksum_type: sha256
description:
  **Efficiently manage and install data fixtures**
  `Charlatan` is a library that you can use in your tests to create database
  fixtures. Its aim is to provide a pragmatic interface that focuses on making it
  simple to define and install fixtures for your tests. It is also agnostic in so
  far as even though it's designed to work out of the box with SQLAlchemy models,
  it can work with pretty much anything else.


pkgId: cdac959e5c2f952743d2199548ccb6022f550e74ff5b6ae2d09aa23ac23f7dd8
name: python-charm-tools
arch: src
version: 3.0.8
epoch: 0
release: 1
summary: Tools for building and maintaining Juju charms
url: https://github.com/juju/charm-tools
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charm-tools-3.0.8-1.src.rpm
checksum_type: sha256
description:
  |build|
  This is a collection of tools to make writing Juju charms easier. See Juju's
  home page for more information.
  https://jujucharms.com/


pkgId: 8ea695935d35b1e7d570a66166f3c42a73647ba8b840c298973f60ebc8744d21
name: python-charmcraftcache
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Fast first-time builds for charmcraft
url: https://pypi.org/project/charmcraftcache/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charmcraftcache-0.4.1-1.src.rpm
checksum_type: sha256
description:
  _Reinventing the wheel_

  Fast first-time builds for [charmcraft](https://github.com/canonical/charmcraft)—on a local machine or CI


  Install `pipx`: https://pipx.pypa.io/stable/installation/
  ```
  pipx install charmcraftcache
  ```


  ```
  ccc add
  ccc pack
  ```

  For best results, add `charm-strict-dependencies: true` to your charmcraft.yaml.



  Instead of downloading wheels from PyPI (which pip does by default), charmcraft builds Python package wheels from source (i.e. with pip install [--no-binary](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-binary)).


  charmcraft builds each charm base in a separate LXC container[^1]. Within each container, pip has an [internal cache](https://pip.pypa.io/en/stable/topics/caching/) for wheels built from source & for HTTP responses.

  charmcraft 2.5 moved the pip internal cache to the LXC host machine, so that one pip cache is used for all LXC containers. (This increases the chance of a cache hit—a faster build.)

  However, charmcraft builds are still slow the first time the wheel is built. This happens on CI runners, when you update dependencies, use a new machine/VM, or contribute to a new charm.

  `charmcraftcache` solves the slow first build.

  [charmcraftcache-hub](https://github.com/canonical/charmcraftcache-hub) maintains a [list of charms](https://github.com/canonical/charmcraftcache-hub/blob/main/charms.json). For each charm, every Python dependency is built from source & uploaded to a GitHub release.

  `ccc pack` downloads these pre-built wheels to charmcraft's pip cache (and then runs `charmcraft pack`).


  Pretty much. The only difference is charmcraftcache-hub wheels are built from source on our runners, instead of built by the package maintainer.

  [^1]: Unless `--destructive-mode` is enabled


pkgId: 91eee8495a2ce06b5789d6027372aea9019a6782f35e9452793827c4aeb595ed
name: python-charmcraftcache
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Fast first-time builds for charmcraft
url: https://pypi.org/project/charmcraftcache/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charmcraftcache-0.5.2-1.src.rpm
checksum_type: sha256
description:
  _Reinventing the wheel_

  Fast first-time builds for [charmcraft](https://github.com/canonical/charmcraft)—on a local machine or CI


  Install `pipx`: https://pipx.pypa.io/stable/installation/
  ```
  pipx install charmcraftcache
  ```


  ```
  ccc add
  ccc pack
  ```

  For best results, add `charm-strict-dependencies: true` to your charmcraft.yaml.



  Instead of downloading wheels from PyPI (which pip does by default), charmcraft builds Python package wheels from source (i.e. with pip install [--no-binary](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-binary)).


  charmcraft builds each charm base in a separate LXC container[^1]. Within each container, pip has an [internal cache](https://pip.pypa.io/en/stable/topics/caching/) for wheels built from source & for HTTP responses.

  charmcraft 2.5 moved the pip internal cache to the LXC host machine, so that one pip cache is used for all LXC containers. (This increases the chance of a cache hit—a faster build.)

  However, charmcraft builds are still slow the first time the wheel is built. This happens on CI runners, when you use a new machine/VM, or when you contribute to a new charm.

  `charmcraftcache` solves the slow first build.

  [charmcraftcache-hub](https://github.com/canonical/charmcraftcache-hub) maintains a [list of charms][list of charms]. For each charm, `charmcraft pack` is used to build Python dependencies from source and the pip wheel cache is uploaded to a GitHub release.

  `ccc pack` downloads these pre-built wheels to charmcraft's pip cache (and then runs `charmcraft pack`).

  Note: Within the GitHub release, each charm has an isolated cache. If the same charm (same GitHub repository and relative path to charmcraft.yaml) is added to the list of charms more than once (with different git refs), the wheels are combined into a single cache. If there are duplicate wheels, the wheel is selected from the ref that is earlier in the [list][list of charms].


  Pretty much. The only difference is charmcraftcache-hub wheels are built from source on our runners, instead of built by the package maintainer.

  [^1]: Unless `--destructive-mode` is enabled

  [list of charms]: https://github.com/canonical/charmcraftcache-hub/blob/main/charms.json


pkgId: c20620d7086965fb6647dcf0e4325e86ce148a115018ec0048afb3b6d2f32c65
name: python-charmcraftst124
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://pypi.org/project/charmcraftst124/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charmcraftst124-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  Temporary compatibility wrapper to use ST124 shorthand notation with older versions of charmcraft 3 that don't support ST124

description:
  > [!WARNING]
  > This project will be deprecated when [ST124 - Multi-base platforms in craft tools](https://docs.google.com/document/d/1QVHxZumruKVZ3yJ2C74qWhvs-ye5I9S6avMBDHs2YcQ/edit) is implemented in [charmcraft](https://github.com/canonical/charmcraft).

  Pack multi-base charms (that include base Ubuntu 24.04) with a single charmcraft.yaml and git branch using the upcoming ST124 "shorthand notation" charmcraft.yaml syntax


  Install `pipx`: https://pipx.pypa.io/stable/installation/
  ```
  pipx install charmcraftst124
  ```



  Only ST124 "shorthand notation" syntax is supported


  ```yaml
  platforms:
    ubuntu@22.04:amd64:
    ubuntu@22.04:arm64:
    ubuntu@24.04:amd64:
    ubuntu@24.04:arm64:
  ```

  Under the `platforms` key, `build-on` and `build-for` syntax are not supported

  The `base` and `bases` keys are not supported


  ```
  charmcraftst124 pack --platform ubuntu@22.04:amd64
  ```

  See `charmcraftst124 pack --help` for more information

  To pack multiple platforms, run `charmcraftst124 pack` once for each platform


  "Shorthand notation" is used when `build-on` is identical to `build-for`. (For example, "ubuntu@22.04:amd64" means build on Ubuntu 22.04 amd64 and build for Ubuntu 22.04 amd64.)

  For charms that depend (directly or indirectly) on Python packages with C extensions (e.g. pyyaml), charmcraft will build wheels where the C extensions only work on `build-on`.

  For example, if a charm is built with
  ```yaml
  platforms:
    foo:
      build-on: ubuntu@22.04:amd64
      build-for:
        - ubuntu@22.04:amd64
        - ubuntu@22.04:arm64
  ```
  the wheels in the *.charm file will contain C extensions that only work on amd64, not arm64.

  The vast majority of charms have at least one Python dependency with C extensions, so the vast majority of charms should use "shorthand notation".


pkgId: eb6ca203fb949949c2f22d0f53d3de473eaad2e16a28e1349aad11419b92145c
name: python-charmed-kubeflow-chisme
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: A collection of helpers for Charms maintained by the Charmed Kubeflow team
url: https://github.com/canonical/charmed-kubeflow-chisme
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charmed-kubeflow-chisme-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Chisme: a Spanish word for gossip, or a story worth telling to your friends.

  This repository is for chisme within the Charmed Kubeflow team's codebase - it is a collection of helpers for use in
  both the Charmed Operators maintained by the [Charmed Kubeflow](ckf) team as well as anyone else who benefits from them.



  * [Exceptions](./src/charmed_kubeflow_chisme/exceptions/README.md): A collection of standard Exceptions for use when writing charms.
  * [Kubernetes](./src/charmed_kubeflow_chisme/kubernetes/README.md): Helpers for interacting with Kubernetes
  * [Lightkube](./src/charmed_kubeflow_chisme/lightkube/README.md): Helpers specific to using or extending [Lightkube](lightkube-rtd)
  * [Pebble](./src/charmed_kubeflow_chisme/pebble/README.md): Helpers for managing pebble when writing charms
  * [Reusable Charm Components](./src/charmed_kubeflow_chisme/components/README.md): The `Component` abstraction that encapsulates any piece of logic for a Charm, a reusable reconcile function `CharmReconciler` that executes `Components`, and a collection of `Components` for things like running Pebble containers or deploying Kubernetes resources
  * [Rock](./src/charmed_kubeflow_chisme/README.md): Utilities for testing rocks
  * [Status Handling](./src/charmed_kubeflow_chisme/status_handling/README.md): Helpers for working with Charm Status objects
  * [Testing](./src/charmed_kubeflow_chisme/testing/README.md): Utilities for testing Charms
  * [Types](./src/charmed_kubeflow_chisme/types/README.md): Reusable typing definitions, useful for adding type hints

  [ckf]: https://charmed-kubeflow.io/
  [lightkube-rtd]: https://lightkube.readthedocs.io/en/latest/



  To publish a new release to Pypi:
  1. Update [setup.cfg](https://github.com/canonical/charmed-kubeflow-chisme/blob/main/setup.cfg#L3) to the new version
     and commit it to the repo via a completed PR
  2. Apply local git tag according to the format `X.X.X` (semantic versioning) on the main branch
  3. Push tag to the repo. Example: `git push origin 0.0.8`
  4. GitHub Action will create a new release on GitHub
  5. Edit release via GitHub UI and click publish
  6. GitHub Action will automatically publish the same commit to PyPi repository


pkgId: 114db83ebb777c3bc154c1e81046046588cc237c1890a5ed24b9752b6b5f4e08
name: python-charms.reactive
arch: src
version: 1.5.3
epoch: 0
release: 1
summary: Framework for writing reactive-style Juju Charms
url: https://github.com/juju-solutions/charms.reactive
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charms.reactive-1.5.3-1.src.rpm
checksum_type: sha256
description:
  This module serves as the basis for creating charms and relation
  implementations using the reactive pattern. You can see its goal and vision in
  `the vision document`_
  The full documentation is available online at: https://charmsreactive.readthedocs.io/


pkgId: ad1e922a3411562c9539daa4c764d2abf8d41a4204d5b9b22d6c5810d935abb2
name: python-charon-vna
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: RF Network Analyzer based on the Pluto SDR
url: https://pypi.org/project/charon-vna/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-charon-vna-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Named after [Pluto's moon](https://en.wikipedia.org/wiki/Charon_(moon)), Charon uses the [ADI Pluto SDR]() as a vector network analyzer. The basic usage is as a 1 port VNA but this can be extended to arbitrarily many ports with the addition of a couple RF switches.



  1. Install LibIIO. This is a dependency of [PyADI-IIO](https://wiki.analog.com/resources/tools-software/linux-software/pyadi-iio).
  On Ubuntu 22.04 just run `sudo apt-get install -y libiio-dev`

  2. `pip install charon-vna`



  There will be some sort of GUI because that sounds useful.
  It will also be accessible over a socket to enable test automation with external (including non-python) code.



  TBD


  I include a default output power lookup table. This is derived from two TX channels of two Pluto SDRs and does not include any of the loss of a coupler or Charon switch board.

  Absolute output power is generally not well calibrated for VNAs anyway and has negligible impact on most measurements so this is probably sufficient for most users. If you're trying to run a power sweep this may be insufficient.

  If you have an RF power meter you can generate your own power calibration.

  Note that unlike the main calibration, power calibration frequencies do not need to match the measurement frequencies. Values are interpolated.



  You need a few things:
  - [Analog Devices Pluto SDR](https://www.analog.com/en/resources/evaluation-hardware-and-software/evaluation-boards-kits/adalm-pluto.html).
  Any variant of the Pluto *should* work too such as the [Pluto+](https://github.com/plutoplus/plutoplus?tab=readme-ov-file)
  - Directional couplers (1 per port up to 4 ports).
  I have been using [AAMCS-UDC-0.5G-18G-10dB-Sf](http://www.aa-mcs.com/wp-content/uploads/documents/AAMCS-UDC-0.5G-18G-10dB-Sf.pdf)
  - Charon switch board - coming soon.
  Without this, you'll be limited to S11 and uncalibrated S21 measurements (with required re-cabling).
  There's nothing special about this particular board, if you want more than 4 ports you can make your own pretty easily. You just need 3 SPxT switches. Note that these switches will see tons of cycles so avoid mechanical switches.
  - SMA cables



  We need two receive channels on the SDR. If you have a Pluto+ that should already be configured and you can skip this step.

  Analog devices has a [guide](https://wiki.analog.com/university/tools/pluto/users/customizing#updating_to_the_ad9364) for enabling the second channel. Ideally this should be set as `ad9361` to enable a wider band of operation in addition to the second channel, however the critical setting is enabling 2r2t.


pkgId: cda0c5362da6c3ddccbdac3f050bd9857fa15ff091ff6b7354edb14ca6daf40f
name: python-chart-builder
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A library for building customizable charts in Python
url: https://github.com/BrandynHamilton/Chart-Builder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chart-builder-0.1.5-1.src.rpm
checksum_type: sha256
description:
  - This library builds off Plotly and automates portions of data cleaning and charting for users.
  - A user only inputs specified parameters such as chart type and columns to chart, enabling quick charting of complex data structures.


pkgId: 35b34ad2964d0e1a017913f21f12d32c93ef7a23c0cd69d68146e11173c43ebe
name: python-chart-studio
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Utilities for interfacing with plotly's Chart Studio
url: https://plot.ly/python/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chart-studio-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This package contains utilities for interfacing with Plotly's Chart Studio service (both Chart Studio cloud and Chart Studio On-Prem).  Prior to plotly.py version 4, This functionality was included in the `plotly` package under the `plotly.plotly` module. As part of plotly.py version 4, the Chart Studio functionality was removed from the `plotly` package and released in this `chart-studio` package.


pkgId: ff24c54ba30b05c5d6a442725a2c2fbbda1e66ab0e200d8295e01b3fab2a794b
name: python-chartart
arch: src
version: 0.0.3.dev36
epoch: 0
release: 1
summary: ChartArt python package
url: https://github.com/pypa/sampleproject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chartart-0.0.3.dev36-1.src.rpm
checksum_type: sha256
description:
  Use
  [Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.

  Change Log

  0.0.1 => 0.0.2
  Added support for =>
  -Publish post without javascript package from notebook
  -Pulish post from standalone python script (Non jupyter environment)


  0.0.2 => 0.0.3
  Added support for features at the time of publishing post. Features will get used as filters.

  0.0.3.dev5 => 0.0.3.dev6
  -Support for status posts compatible with new low code platform.
  Example:

  ```

  filters = {
      "dateAdded": datetime.datetime.now().isoformat() + 'Z',
      'rowSubscriptionCol': 'vendor',
      'type': 'aggregatePost'
  }

  data = {
      'count': 5,
      'status': 'Warning',
      'vendor': 'GCP'
  }

  post = Post(postId='GCP_aggregatePost', postTitle='# Aggregated Post')
  post.addFilters(filters)
  post.createPost(data=data)

  ```
  0.0.3.dev6 => 0.0.3.dev7
  -Added Exception handling code if response is not in json format

  0.0.3.dev7 => 0.0.3.dev8
  -Added code to retry 5xx error code

  0.0.3.dev7 => 0.0.3.dev10
  -Resolved unauthorized error and changed sleep time

  0.0.3.dev12 => 0.0.3.dev13
  - Added line/bar/scatter chart subtypes
  - line type : line, area, spline, stepLine, splineArea, stepArea, stackedLine, stackedArea, stackedArea100, stackedLine100
  - bar type : bar,column,stackedBar,stackedColumn,stackedBar,stackedBar100,stackedColumn100
  - scatter : bubble , if size is specified as list of float scatter chart will get ploted as bubble chart

  0.0.3.dev14 => 0.0.3.dev15
  - Tree Map : c (color) param is optional
  - Map : shapeDataField is new optional param (defaults to key 'Name'). primaryValueMapper and data is optional parameters now. This will be usefull for markers/bubbles where we dont need these inputs.
  - Map : added support fo sub layers.

  0.0.3.dev18
  - Added startAngle, endAngle, radius, groupTo in circular chart
  - Added number format on axis

  0.0.3.dev19
  - added support to specify axis type
  - Made default bin interval is 0 . 0 means syncfusion will calculate internally.

  0.0.3.dev20
  - preview and previewPost url should route should start with /  e.g  earlier http://localhost:port/#preview  now http://localhost:port/#/preview

  0.0.3.dev21
  - Fix for communicate with Jupyter kernel

  0.0.3.dev22
  - Fix for setting axis type on figure object

  0.0.3.dev23
  - Added tooltip related parameters for map

  0.0.3.dev25
  - Added datetime.date as supported type for datetime axis

  0.0.3.dev26
  - Inmemory chart inside post

  0.0.3.dev29
  - Inmemory aggregate posts

  0.0.3.dev30
  - for table chart now we can specify column types.
  - by default we will not show index column in table. User can specify it if needed.

  0.0.3.dev31
  - Resolved issue of technical indicator in charts

  0.0.3.dev32
  - Moved candle chart under cartesian chart ubrella
  - Added generic method to add charts mainly required for drilldown table

  0.0.3.dev33
  - Multi axis support

  0.0.3.dev34
  - Date time axis x support for bar chart. Removed check of check_not_datetime(x)

  0.0.3.dev35
  - support for isVisibleInLegend on series

  0.0.3.dev36
  - support for drilldown details at figure level.


pkgId: 788b4bd6b01175faeb696d7909fd714ea596c026e16bbc7807367ff0d872700f
name: python-chartfactor
arch: src
version: 5.1.19
epoch: 0
release: 1
summary: Integrates ChartFactor with Jupyter Notebooks
url: https://github.com/Aktiun/chartfactor-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chartfactor-5.1.19-1.src.rpm
checksum_type: sha256
description:
  [ChartFactor Py](https://chartfactor.com/doc/latest/cfpy_overview/) is built on top of [ChartFactor](https://chartfactor.com), the lightweight visual analytics platform. It includes [ChartFactor Studio](https://chartfactor.com/doc/latest/studio_intro/) and the [ChartFactor Toolkit](https://chartfactor.com/doc/latest/architecture/) between other components.



  Visit the [installation section](https://chartfactor.com/doc/latest/cfpy_installing/) in the ChartFactor Py documentation for a detailed guide.



  Create a new notebook and do the following



  ```python
  from chartfactor import *
  import pandas as pd
  ```



  ```python
  titanic = pd.read_csv('https://chartfactor.com/resources/tutorials/titanic.csv')
  ```



  ```python
  cf.studio("My titanic app")
  ```


  ![image](https://chartfactor.com/resources/images/chartfactor-py/studio-empty.png)


  ![image](https://chartfactor.com/resources/images/chartfactor-py/studio-widgets.png)


pkgId: b188d4a6bfcabca12e0cda354062980bf3f3839ea1c3506885b26507fe2aded3
name: python-chartify
arch: src
version: 5.0.1
epoch: 0
release: 1
summary: Python library to make plotting simpler for data scientists
url: https://github.com/spotify/chartify
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chartify-5.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Status](https://img.shields.io/badge/Status-Beta-blue.svg)
  ![Latest release](https://img.shields.io/badge/Release-5.0.1-blue.svg "Latest release: 5.0.1")
  ![python](https://img.shields.io/badge/Python-3.9-blue.svg "Python 3.9")
  ![python](https://img.shields.io/badge/Python-3.10-blue.svg "Python 3.10")
  ![python](https://img.shields.io/badge/Python-3.11-blue.svg "Python 3.11")
  ![CI](https://github.com/spotify/chartify/workflows/Tox/badge.svg "Tox")
  Chartify is a Python library that makes it easy for data scientists to create charts.


pkgId: 16df413825744d7ab681bfd5365cdbd18934cece409569b2dd9532f01493b2d3
name: python-chartkick
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Create beautiful JavaScript charts with one line of Python
url: https://github.com/ankane/chartkick.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chartkick-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Create beautiful JavaScript charts with one line of Python. No more fighting with charting libraries!

  [See it in action](https://chartkick.com/python)

  **Chartkick.py 1.0 was recently released** - see [how to upgrade](#upgrading)

  [![Build Status](https://github.com/ankane/chartkick.py/workflows/build/badge.svg?branch=master)](https://github.com/ankane/chartkick.py/actions)



  Run:

  ```sh
  pip install chartkick
  ```

  Then follow the instructions for your web framework:

  - [Django](#django)
  - [Flask](#flask)

  This sets up Chartkick with [Chart.js](https://www.chartjs.org/). For other charting libraries, see [these instructions](#additional-charting-libraries).



  Add to `INSTALLED_APPS` in `settings.py`

  ```python
  INSTALLED_APPS = [
      'chartkick.django',
      
  ]
  ```

  Load the JavaScript

  ```django
  {% load static %}

  <script src="{% static 'chartkick/Chart.bundle.js' %}"></script>
  <script src="{% static 'chartkick/chartkick.js' %}"></script>
  ```

  Create a chart in a view

  ```python
  from chartkick.django import PieChart

  def index(request):
      chart = PieChart({'Blueberry': 44, 'Strawberry': 23})
      return render(request, 'home/index.html', {'chart': chart})
  ```

  And add it to the template

  ```django
  {{ chart }}
  ```



  Register the blueprint

  ```python
  from chartkick.flask import chartkick_blueprint

  app.register_blueprint(chartkick_blueprint)
  ```

  Load the JavaScript

  ```jinja
  <script src="{{ url_for('chartkick.static', filename='Chart.bundle.js') }}"></script>
  <script src="{{ url_for('chartkick.static', filename='chartkick.js') }}"></script>
  ```

  Create a chart in a route

  ```python
  from chartkick.flask import PieChart

  def index():
      chart = PieChart({'Blueberry': 44, 'Strawberry': 23})
      return render_template('home/index.html', chart=chart)
  ```

  And add it to the template

  ```django
  {{ chart }}
  ```



  Line chart

  ```python
  LineChart({'2023-01-01': 11, '2023-01-02': 6})
  ```

  Pie chart

  ```python
  PieChart({'Blueberry': 44, 'Strawberry': 23})
  ```

  Column chart

  ```python
  ColumnChart({'Sun': 32, 'Mon': 46, 'Tue': 28})
  ```

  Bar chart

  ```python
  BarChart({'Work': 32, 'Play': 1492})
  ```

  Area chart

  ```python
  AreaChart({'2021-01-01': 11, '2021-01-02': 6})
  ```

  Scatter chart

  ```python
  ScatterChart([[174.0, 80.0], [176.5, 82.3]], xtitle='Size', ytitle='Population')
  ```

  Geo chart - *Google Charts*

  ```python
  GeoChart({'United States': 44, 'Germany': 23, 'Brazil': 22})
  ```

  Timeline - *Google Charts*

  ```python
  Timeline([['Washington', '1789-04-29', '1797-03-03'], ['Adams', '1797-03-03', '1801-03-03']])
  ```

  Multiple series

  ```python
  data = [
      {'name': 'Workout', 'data': {'2021-01-01': 3, '2021-01-02': 4}},
      {'name': 'Call parents', 'data': {'2021-01-01': 5, '2021-01-02': 3}}
  ]
  LineChart(data)
  ```



  Data can be a dictionary, list, or URL.



  ```python
  LineChart({'2023-01-01': 2, '2023-01-02': 3})
  ```



  ```python
  LineChart([['2023-01-01', 2], ['2023-01-02', 3]])
  ```



  Make your pages load super fast and stop worrying about timeouts. Give each chart its own endpoint.

  ```python
  LineChart('/charts/tasks')
  ```



  Width and height

  ```python
  LineChart(data, width='800px', height='500px')
  ```

  Min and max values

  ```python
  LineChart(data, min=1000, max=5000)
  ```

  `min` defaults to 0 for charts with non-negative values. Use `None` to let the charting library decide.

  Min and max for x-axis - *Chart.js*

  ```python
  LineChart(data, xmin='2021-01-01', xmax='2022-01-01')
  ```

  Colors

  ```python
  LineChart(data, colors=['#b00', '#666'])
  ```

  Stacked columns or bars

  ```python
  ColumnChart(data, stacked=True)
  ```

  Discrete axis

  ```python
  LineChart(data, discrete=True)
  ```

  Label (for single series)

  ```python
  LineChart(data, label='Value')
  ```

  Axis titles

  ```python
  LineChart(data, xtitle='Time', ytitle='Population')
  ```

  Straight lines between points instead of a curve

  ```python
  LineChart(data, curve=False)
  ```

  Hide points

  ```python
  LineChart(data, points=False)
  ```

  Show or hide legend

  ```python
  LineChart(data, legend=False)
  ```

  Specify legend position

  ```python
  LineChart(data, legend='bottom')
  ```

  Donut chart

  ```python
  PieChart(data, donut=True)
  ```

  Prefix, useful for currency - *Chart.js, Highcharts*

  ```python
  LineChart(data, prefix='$')
  ```

  Suffix, useful for percentages - *Chart.js, Highcharts*

  ```python
  LineChart(data, suffix='%')
  ```

  Set a thousands separator - *Chart.js, Highcharts*

  ```python
  LineChart(data, thousands=',')
  ```

  Set a decimal separator - *Chart.js, Highcharts*

  ```python
  LineChart(data, decimal=',')
  ```

  Set significant digits - *Chart.js, Highcharts*

  ```python
  LineChart(data, precision=3)
  ```

  Set rounding - *Chart.js, Highcharts*

  ```python
  LineChart(data, round=2)
  ```

  Show insignificant zeros, useful for currency - *Chart.js, Highcharts*

  ```python
  LineChart(data, round=2, zeros=True)
  ```

  Friendly byte sizes - *Chart.js*

  ```python
  LineChart(data, bytes=True)
  ```

  Specify the message when data is loading

  ```python
  LineChart(data, loading='Loading...')
  ```

  Specify the message when data is empty

  ```python
  LineChart(data, empty='No data')
  ```

  Refresh data from a remote source every `n` seconds

  ```python
  LineChart(url, refresh=60)
  ```

  You can pass options directly to the charting library with:

  ```python
  LineChart(data, library={'backgroundColor': '#eee'})
  ```

  See the documentation for [Chart.js](https://www.chartjs.org/docs/), [Google Charts](https://developers.google.com/chart/interactive/docs/gallery), and [Highcharts](https://api.highcharts.com/highcharts) for more info.

  To customize datasets in Chart.js, use:

  ```python
  LineChart(data, dataset={'borderWidth': 10})
  ```

  You can pass this option to individual series as well.



  You can pass a few options with a series:

  - `name`
  - `data`
  - `color`
  - `dataset` - *Chart.js only*
  - `points` - *Chart.js only*
  - `curve` - *Chart.js only*



  If you want to use the charting library directly, get the code with:

  ```python
  LineChart(data, code=True)
  ```

  The code will be logged to the JavaScript console. JavaScript functions cannot be logged, so it may not be identical.



  *Chart.js only*

  Give users the ability to download charts. It all happens in the browser - no server-side code needed.

  ```python
  LineChart(data, download=True)
  ```

  Safari will open the image in a new window instead of downloading.

  Set the filename

  ```python
  LineChart(data, download={'filename': 'boom'})
  ```

  Set the background color

  ```python
  LineChart(data, download={'background': '#ffffff'})
  ```

  Set title

  ```python
  LineChart(data, title='Awesome chart')
  ```



  - [Google Charts](#google-charts)
  - [Highcharts](#highcharts)



  Load the JavaScript

  Django

  ```django
  {% load static %}

  <script src="https://www.gstatic.com/charts/loader.js"></script>
  <script src="{% static 'chartkick/chartkick.js' %}"></script>
  ```

  Flask

  ```jinja
  <script src="https://www.gstatic.com/charts/loader.js"></script>
  <script src="{{ url_for('chartkick.static', filename='chartkick.js') }}"></script>
  ```



  Download [highcharts.js](https://code.highcharts.com/highcharts.js) and load the JavaScript

  Django

  ```django
  {% load static %}

  <script src="{% static 'highcharts.js' %}"></script>
  <script src="{% static 'chartkick/chartkick.js' %}"></script>
  ```

  Flask

  ```jinja
  <script src="{{ url_for('static', filename='highcharts.js') }}"></script>
  <script src="{{ url_for('chartkick.static', filename='chartkick.js') }}"></script>
  ```



  If more than one charting library is loaded, choose between them with:

  ```python
  LineChart(data, adapter='google')  # or highcharts or chartjs
  ```



  A big thanks to [Mher Movsisyan](https://github.com/mher) for creating the [initial version](https://github.com/mher/chartkick.py).





  For Django, change `chartkick` to `chartkick.django` under `INSTALLED_APPS` in `settings.py` and remove `chartkick.js()` from `STATICFILES_DIRS`. Then update charts to use classes.

  ```python
  from chartkick.django import LineChart

  LineChart({'2023-01-01': 11, '2023-01-02': 6})
  ```

  For Flask, switch to the [included blueprint](#flask) (available in 1.0.1). Then update charts to use classes.

  ```python
  from chartkick.flask import LineChart

  LineChart({'2023-01-01': 11, '2023-01-02': 6})
  ```



  View the [changelog](https://github.com/ankane/chartkick.py/blob/master/CHANGELOG.md)



  Everyone is encouraged to help improve this project. Here are a few ways you can help:

  - [Report bugs](https://github.com/ankane/chartkick.py/issues)
  - Fix bugs and [submit pull requests](https://github.com/ankane/chartkick.py/pulls)
  - Write, clarify, or fix documentation
  - Suggest or add new features

  To get started with development:

  ```sh
  git clone https://github.com/ankane/chartkick.py.git
  cd chartkick.py
  pip install -r requirements.txt
  pytest
  ```


pkgId: 6e432b0eda51e8514894b577028fde6647969f2038e50e756d433adac6718073
name: python-chartlets
arch: src
version: 0.0.28
epoch: 0
release: 1
summary: Backend for server-configured charts powered by Vega Altair.
url: https://pypi.org/project/chartlets/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chartlets-0.0.28-1.src.rpm
checksum_type: sha256
description:
  [![Backend CI workflow](https://github.com/bcdev/chartlets/actions/workflows/backend-ci.yml/badge.svg)](https://github.com/bcdev/chartlets/actions/workflows/backend-ci.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/chartlets)](https://pypi.org/project/chartlets/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Chartlets is a software framework that allows websites developed with
  React to be extended by server-side widgets programmed in Python or other
  programming languages.

  This is the Python backend library of the framework.

  For details refer to the [documentation](https://bcdev.github.io/chartlets/).



  ``` bash
  mamba env create
  conda activate chartlets
  python -m chartlets.demo.server
  ```


pkgId: ff100dd5e08a30f3f1c42847ae109d286832f1732295ffe89d9d35a1b54543f9
name: python-chartlyrics
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Wrapper for chartlyrics api: http://api.chartlyrics.com
url: https://github.com/matheusfillipe/chartlyrics
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chartlyrics-0.1.7-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI Build Status](https://circleci.com/gh/matheusfillipe/chartlyrics.svg?style=shield)](https://circleci.com/gh/matheusfillipe/chartlyrics)
  [![Pypi](https://badge.fury.io/py/chartlyrics.svg)](https://pypi.org/project/chartlyrics/)
  [![Chat with me on irc](https://img.shields.io/badge/-IRC-gray?logo=gitter)](https://connect.h4ks.com/)



  This is a simple wrapper for: http://api.chartlyrics.com. You can search for songs, artists and get the lyrics.



  ``` sh
  pip install chartlyrics
  ```



  ```python
  from chartlyrics import ChartLyricsClient

  client = ChartLyricsClient()

  for song in client.search_text("starts with one"):
      if "park" in song.artist.lower():
        print(song.artist)  # Linking Park
        print(song.lyrics)  # Starts with one\n One thing I dont know why...
  ```

  You can also use `song.lyrics_object` which will return a `Lyrics` object that you can index strophes and verses on:

  ```python
  lyrics = song.lyrics_object
  print(lyrics[0][-1])  # first strophe last verse
  ```

  Check the `tests` for more examples.



  Fork the repo, run:

  ```sh
  poetry install
  ```

  Add features, write tests, run:

  ```sh
  poetry run pytest
  ```

  Create a Pull request.


pkgId: 88aa76287cf5b048748978b967a3e82367dcfe470f5daec6b1f5f194576cc5c0
name: python-chaseinvest-api
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: An unofficial API for Chase Invest
url: https://github.com/MaxxRK/chaseinvest-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaseinvest-api-0.3.0-1.src.rpm
checksum_type: sha256
description:
  I am new to coding and new to open-source. I would love any help and suggestions!

  I am not a financial advisor and not affiliated with Chase in any way. Use this tool at your own risk. I am not responsible for any losses or damages you may incur by using this project. This tool is provided as-is with no warranty.

  Install using pypi:
  ```
  pip install chaseinvest-api
  ```
  This package requires playwright. After installing chaseinvest-api, you will need to finish the install of playwright. You can do this in most cases by running the command:
  ```
  playwright install
  ```
  If you would like some more information on this, you can find it [here](https://playwright.dev/python/docs/intro).

  The code below will:
  - Login and print account info.
  - Get a quote for 'INTC' and print out the information
  - Place a market order for 'INTC' on the first account in the `account_numbers` list
  - Print out the order confirmation
  ```python
  import sys
  from chase import account as acc
  from chase import order as och
  from chase import session
  from chase import symbols as sym

  cs = session.ChaseSession(title="Title of your profile here", headless=False, profile_path='your/profile/path')

  login_one = cs.login("your_username", "your_password", "last_four_of_your_cell_phone")

  if login_one == False:
      print('Login succeeded without needing 2fa...')
  else:
      code = input('Please input code that was sent to your phone: ')
      login_two = cs.login_two(code)

  all_accounts = acc.AllAccount(cs)
  if all_accounts.account_connectors is None:
      sys.exit("Failed to get account connectors exiting script...")

  print("====================================")
  print(f"Account Identifiers: {all_accounts.account_connectors}")

  account_ids = list(all_accounts.account_connectors.keys())
  print("====================================")
  print("ACCOUNT DETAILS")
  print("====================================")
  for account in account_ids:
      account = acc.AccountDetails(account, all_accounts)
      print(account.nickname, account.mask, account.account_value)
  print("====================================")

  print("====================================")
  print("HOLDINGS")
  for account in account_ids:
      print("====================================")
      print(f"Account: {all_accounts.account_connectors[account]}")
      symbols = sym.SymbolHoldings(account, cs)
      success = symbols.get_holdings()
      if success:
          for i, symbol in enumerate(symbols.positions):
              if symbols.positions[i]["instrumentLongName"] == "Cash and Sweep Funds":
                  symbol = symbols.positions[i]["instrumentLongName"]
                  value = symbols.positions[i]["marketValue"]["baseValueAmount"]
                  print(f"Symbol: {symbol} Value: {value}")
              elif symbols.positions[i]["assetCategoryName"] == "EQUITY":
                  try:
                      symbol = symbols.positions[i]["positionComponents"][0][
                          "securityIdDetail"
                      ][0]["symbolSecurityIdentifier"]
                      value = symbols.positions[i]["marketValue"]["baseValueAmount"]
                      quantity = symbols.positions[i]["tradedUnitQuantity"]
                      print(f"Symbol: {symbol} Value: {value} Quantity: {quantity}")
                  except KeyError:
                      symbol = symbols.positions[i]["securityIdDetail"]["cusipIdentifier"]
                      value = symbols.positions[i]["marketValue"]["baseValueAmount"]
                      quantity = symbols.positions[i]["tradedUnitQuantity"]
                      print(f"Symbol: {symbol} Value: {value} Quantity: {quantity}")
      else:
          print(f"Failed to get holdings for account {account}")
  print("====================================")

  order = och.Order(cs)

  print("====================================")
  print("ORDER STATUSES")
  for account in account_ids:
      order_statuses = order.get_order_statuses(account)
      print("====================================")
      print(f"Account: {all_accounts.account_connectors[account]}")
      for order_status in order_statuses["orderSummaries"]:
          order_number = order_status["orderIdentifier"]
          order_type = order_status["tradeActionCode"]
          order_status_code = order_status["orderStatusCode"]
          print(
              f"Order Number: {order_number} Side: {order_type} Status: {order_status_code}"
          )
  print("====================================")

  symbol_quote = sym.SymbolQuote(account_ids[0], cs, "INTC")
  print("====================================")
  print("SYMBOL QUOTE")
  print(
      f"{symbol_quote.security_description} ask price {symbol_quote.ask_price}, @{symbol_quote.as_of_time} and the last trade was {symbol_quote.last_trade_price}."
  )
  print("====================================")

  messages = order.place_order(
      account_ids[0],
      1,
      och.PriceType.MARKET,
      "INTC",
      och.Duration.DAY,
      och.OrderSide.BUY,
      dry_run=True,
  )
  if messages["ORDER CONFIRMATION"] != "":
      print(messages["ORDER CONFIRMATION"])
  else:
      print(messages)
  ```


pkgId: 0327cc8e737655375dcd16082f0735619a8637526a111a582e1a5bf625217107
name: python-chaski-confluent
arch: src
version: 0.1a5
epoch: 0
release: 1
summary: Chaski Confluent
url: https://pypi.org/project/chaski-confluent/
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaski-confluent-0.1a5-1.src.rpm
checksum_type: sha256
description:
  [Chaski-Confluent](https://github.com/dunderlab/python-chaski) is an advanced distributed communication framework designed to
  streamline data exchange between nodes over TCP/IP networks. It features robust
  node discovery, efficient message handling, dynamic pairing based on subscription
  topics, and extends functionality with remote interactions, ensuring resilience and
  flexibility in complex network topologies.
  ![GitHub top language](https://img.shields.io/github/languages/top/dunderlab/python-chaski)
  ![PyPI - License](https://img.shields.io/pypi/l/chaski)
  ![PyPI](https://img.shields.io/pypi/v/chaski)
  ![PyPI - Status](https://img.shields.io/pypi/status/chaski)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chaski)
  ![GitHub last commit](https://img.shields.io/github/last-commit/dunderlab/python-chaski)
  ![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/dunderlab/python-chaski)
  [![Documentation Status](https://readthedocs.org/projects/chaski-confluent/badge/?version=latest)](https://chaski-confluent.readthedocs.io/en/latest/?badge=latest)
  The project aims to provide a reliable and scalable solution for distributed systems,
  addressing the challenges of latency management, subscription routing, remote method
  invocation, and connection stability. With **Chaski-Confluent**, developers can easily
  build and maintain efficient communication protocols in their distributed applications.
  **Chaski-Confluent** is a comprehensive solution to the challenges of distributed systems.
  Built with robustness and scalability in mind, it leverages advanced networking
  techniques to facilitate data exchange between nodes. Its architecture allows for
  dynamic scaling, maintaining communication efficiency without compromising performance
  as the network grows. This makes **Chaski-Confluent** an ideal choice for resilient and
  scalable distributed applications that need to adapt to changing conditions and workloads.
  One of the standout features of **Chaski-Confluent** is its support for both TCP and UDP
  protocols. This dual-protocol capability ensures that developers can choose the most
  appropriate method for their specific use cases. Additionally, the sophisticated node
  discovery mechanism and intelligent subscription-based message routing enable the
  creation of dynamic network topologies where nodes can communicate effortlessly.
  These features, along with effective latency management and remote method invocation,
  position **Chaski-Confluent** as a powerful tool for developing modern distributed systems.

  The **Chaski-Confluent** framework provides various powerful features that make it suitable for managing distributed systems. Here are some of the key features:
  **TCP and UDP Communication:**
  Chaski Confluent supports both TCP and UDP protocols, allowing for reliable and timely message delivery between nodes. The framework ensures efficient data transfer irrespective of the underlying network conditions.
  **Node Discovery and Pairing:**
  Automatic discovery of nodes based on shared subscription topics is a crucial feature. Chaski Confluent facilitates the pairing of nodes with common interests, making it easy to build dynamic and scalable network topologies.
  **Ping and Latency Management:**
  The framework includes built-in mechanisms for measuring latency between nodes through ping operations. This helps in maintaining healthy connections and ensures that communication within the network is optimal.
  **Subscription Management:**
  Nodes can subscribe to specific topics, and messages are routed efficiently based on these subscriptions. This allows for effective communication and data exchange only with relevant nodes.
  **Keep-alive and Disconnection Handling:**
  Chaski Confluent ensures that connections between nodes remain active by implementing keep-alive checks. If a connection is lost, the framework handles reconnection attempts gracefully to maintain network integrity.
  **Remote Method Invocation:**
  The Chaski Remote class enables remote method invocation and interaction across distributed nodes. Nodes can communicate transparently, invoking methods and accessing attributes on remote objects as if they were local.
  **Security:**
  Implement robust security measures to protect data and ensure safe communication between the nodes. Features like encryption and authentication are essential to safeguarding the integrity of the network. For example, you can set up a Certificate Authority (CA) within your network to manage SSL certificates and ensure encrypted communication.
  **Flexible Configuration:**
  The framework offers a flexible configuration system, allowing users to customize various parameters such as timeouts, retry intervals, and buffer sizes. This adaptability helps in optimizing the performance according to specific requirements.
  **Logging and Monitoring:**
  Comprehensive logging and monitoring capabilities are integrated into the framework, providing real-time insights into the network activity and performance metrics. This aids in troubleshooting and maintaining the health of the system.


  The Chaski_ Node is an essential component of the Chaski-Confluent system. It is responsible for initiating and managing
  network communication between distributed nodes. This class handles functions such as connection establishment,
  message passing, node discovery, and pairing based on shared subscriptions.

  The Chaski-Streamer extends the functionality of Chaski-Node by introducing asynchronous message streaming capabilities.
  It sets up an internal message queue to manage incoming messages, allowing efficient and scalable message processing within a distributed environment.
  The ChaskiStreamer can enter an asynchronous context, enabling the user to stream messages using the `async with` statement.
  This allows for handling messages dynamically as they arrive, enhancing the responsiveness and flexibility of the system.

  The Chaski-Remote class enhances the Chaski-Node functionality by enabling remote method invocation and interaction
  across distributed nodes. It equips nodes with the ability to communicate transparently, invoking methods and accessing
  attributes on remote objects as if they were local. This is achieved by utilizing the Proxy class, which wraps around
  the remote objects and provides a clean interface for method calls and attribute access.

  The core functionalities of Chaski-Confluent revolve around efficient and scalable
  communication mechanisms integral to modern distributed systems. Central to its
  architecture is the use of the Python `asyncio` library, which facilitates asynchronous
  programming to manage concurrent connections without the overhead of traditional
  threading models. This allows for high-performance message handling and real-time
  node interactions, optimizing the framework for low-latency and responsive communication.
  In implementing Chaski-Confluent, leveraging asyncio ensures that tasks such as
  node discovery, subscription management, and remote method invocation are carried
  out efficiently. Asynchronous programming enables the framework to handle multiple
  network operations simultaneously, maintaining high throughput and scalability even
  under heavy network loads. The integration of `asyncio` thus provides a robust
  foundation for building dynamic and resilient distributed systems, ensuring seamless
  and efficient data exchange across nodes.

  Certification Authority (CA) is crucial for securing communications within the Chaski-Confluent framework.
  By acting as a trust anchor, CA issues and manages digital certificates, ensuring that nodes in the network
  can verify each other's identities. This mechanism helps to maintain the integrity and confidentiality of
  the data being exchanged.
  The CA in Chaski-Confluent can generate, sign, and distribute SSL certificates, providing a robust
  security layer. This ensures that all communication between nodes is encrypted and authenticated,
  significantly reducing the risk of data breaches or unauthorized access.


pkgId: 227d73769a61e9ed4b3331e1f58f9e4d82138e95f49d5179b1f2c2c482b59f12
name: python-chaste-codegen
arch: src
version: 0.10.5
epoch: 0
release: 1
summary: Code generation for cardiac Chaste
url: https://github.com/ModellingWebLab/chaste-codegen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaste-codegen-0.10.5-1.src.rpm
checksum_type: sha256
description:
  ![workflow](https://github.com/ModellingWebLab/chaste-codegen/actions/workflows/pytest.yml/badge.svg) [![Documentation Status](https://readthedocs.org/projects/chaste-codegen/badge/?version=latest)](https://chaste-codegen.readthedocs.io/en/latest/?badge=latest) [![codecov](https://codecov.io/gh/ModellingWebLab/chaste-codegen/branch/master/graph/badge.svg)](https://codecov.io/gh/ModellingWebLab/chaste-codegen)



  The `chaste_codegen` module takes [CellML](https://www.cellml.org/) models as input, via [cellmlmanip](https://github.com/ModellingWebLab/cellmlmanip) to read and manipulate them, then uses templating to generate C++ code.

  The [jinja2](http://jinja.pocoo.org/) templating engine is used.


  We recommend installing chaste_codegen in a virtual environment (using virtualenv or conda)

  Users install `chaste_codegen` using pip.

  ```
  pip install chaste_codegen
  ```


  After installation, chaste_codegen can be called using the `chaste_codegen` command:
  ```
  usage: chaste_codegen [-h] [--version] [--normal] [--cvode]
                        [--cvode-data-clamp] [--backward-euler] [--rush-larsen]
                        [--grl1] [--grl2] [--rush-larsen-labview]
                        [--rush-larsen-c] [-j] [-o OUTFILE]
                        [--output-dir OUTPUT_DIR] [--show-outputs] [-c CLS_NAME]
                        [-q] [--skip-ingularity-fixes] [-y] [--opt] [-m]
                        [--lookup-table <metadata tag> min max step]
                        [--use-model-factory]
                        cellml_file
  chaste_codegen: error: the following arguments are required: cellml_file

  ```

  For more information about the available options call
  `chaste_codegen -h` or see the [CodeGenerationFromCellML guide](https://chaste.github.io/docs/user-guides/code-generation-from-cellml/)



  For release notes see [RELEASE.md](./RELEASE.md)



  API documentation explaining how to use cellmlmanip can be found on [readthedocs](https://chaste-codegen.readthedocs.io/en/latest/)



  For guidelines on contributing to `chaste_codegen`, please see [CONTRIBUTING.md](CONTRIBUTING.md).


pkgId: 6da4858828dae860f644115c64d483bebba0ca11e5d6217c7f3211e7d6b98260
name: python-chaster-sdk
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Chaster python sdk
url: https://github.com/PoofyEnigma/chaster-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaster-sdk-0.1.7-1.src.rpm
checksum_type: sha256
description:
  `pip install --upgrade chaster-sdk`

  ```python
  from chaster import api
  import os
  chaster_api = api.ChasterAPI(os.environ.get('CHASTER_BEARER_TOKEN'), user_agent='your_username/1.0')
  ```

  See the [demos](https://github.com/PoofyEnigma/chaster-python-sdk/tree/main/demos) folder for examples of utilizing the SDK.

  [pypi project](https://pypi.org/project/chaster-sdk/)



  You want to? Nice! Hmu on Discord, username PupHimbo



  Repository started by copying [this python boilerplate](https://github.com/AlexanderWillner/python-boilerplate)


pkgId: 41c137522ff53b436dcdebc46afe1b3007590e1834d90370b99da36e8ef775ff
name: python-chat-downloader
arch: src
version: 0.2.8
epoch: 0
release: 1
url: https://github.com/xenova/chat-downloader
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat-downloader-0.2.8-1.src.rpm
checksum_type: sha256
summary:
  A simple tool used to retrieve chat messages from livestreams, videos, clips and past broadcasts. No authentication needed!

description:
      usage: chat_downloader [-h] [--version] [--start_time START_TIME]
                             [--end_time END_TIME]
                             [--message_types MESSAGE_TYPES | --message_groups MESSAGE_GROUPS]
                             [--max_attempts MAX_ATTEMPTS]
                             [--retry_timeout RETRY_TIMEOUT]
                             [--interruptible_retry [INTERRUPTIBLE_RETRY]]
                             [--max_messages MAX_MESSAGES]
                             [--inactivity_timeout INACTIVITY_TIMEOUT]
                             [--timeout TIMEOUT] [--format FORMAT]
                             [--format_file FORMAT_FILE] [--chat_type {live,top}]
                             [--ignore IGNORE]
                             [--message_receive_timeout MESSAGE_RECEIVE_TIMEOUT]
                             [--buffer_size BUFFER_SIZE] [--output OUTPUT]
                             [--overwrite [OVERWRITE]] [--sort_keys [SORT_KEYS]]
                             [--indent INDENT] [--pause_on_debug | --exit_on_debug]
                             [--logging {none,debug,info,warning,error,critical} | --testing | --verbose | --quiet]
                             [--cookies COOKIES] [--proxy PROXY]
                             url
  For example, to save messages from a livestream to a JSON file, you can use:
     $ chat_downloader https://www.youtube.com/watch?v=jfKfPfyJRdk --output chat.json
  For a description of these options, as well as advanced command line use-cases and examples, consult the `Command Line Usage <https://chat-downloader.readthedocs.io/en/latest/cli.html#command-line-usage>`_ page.


pkgId: b4dadebf6894d63e94cc72e2ea50f6d9d46857c98bfa0b948c9658e096f60cdf
name: python-chat-exporter
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: A simple Discord chat exporter for Python Discord bots.
url: https://github.com/mahtoid/DiscordChatExporterPy
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat-exporter-2.8.0-1.src.rpm
checksum_type: sha256
description:
  To install the library to your virtual environment, for bot usage, run the command:
  ```sh
  pip install chat-exporter
  ```
  To clone the repository locally, run the command:
  ```sh
  git clone https://github.com/mahtoid/DiscordChatExporterPy
  ```


pkgId: 452d470f1618286b448a6571b902905a1c7b5877eb38a240468a5507c5459091
name: python-chat-in-a-nutshell
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A terminal-based script for interacting with OpenAI's API.
url: https://github.com/thedavidnovak/chat-in-a-nutshell
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat-in-a-nutshell-1.3.0-1.src.rpm
checksum_type: sha256
description:
  This script provides a simple way to chat with OpenAI. It allows you to communicate with the ChatGPT model directly from your terminal.




  ```
  $ ch -m 'Write a Python function to greet the person reading this text.'
  ```


  ````
  Chat
  Model: gpt-3.5-turbo, temperature: 0.0
  System: You are a skilled Python programmer who writes tersely.
  Message: Write a Python function to greet the person reading this text.

  Sure, here you go!

  ```python
  def greet():
      print("Hello there!")
  ```

  This code defines a function called `greet()` that, when called, will print the greeting "Hello there!" to the console.
  (83 tokens used.)
  ````


  First, there is a recap of the request sent to the API with selected arguments. Next, chat completion API's response is displayed. Output also includes token count (e.g., 83 tokens used) at the end.





  The message is specified using the `--message, -m` argument.
  ```
  $ ch -m 'Write a Python function `hello_world`.'
  ```


  The default `system` message is: 'You are a skilled Python programmer who writes tersely.' You can change it by specifying the `--system, -s` argument inside the current command:
  ```
  $ ch -s 'You are a remarkable Italian teacher.' -m 'Translate "Hello there!"'
  ```
  From the version `v1.1.0` the recent system message becomes the default one until further change (or configuration file deletion).



  On/off flag indicating whether a conversation is intended and messages will be appended to the list of messages in the configuration file. Use `--conversation, -c` argument inside the current command.



  You may specify the model that will be used for the API requests (until further change).



  The temperature may be set using the `--temperature, -t` argument. The default value for this script is 0 (lowest).



  Specify the path to save the audio response using the `--save-audio` argument.



  List available OpenAI models using the `--available-models` argument.



  List available ChatGPT models using the `--available-models-gpt` argument.



  To use this script, you will need to have the following:
  - Python 3.7.1 or higher
  - An OpenAI API key (stored in an environment variable `OPENAI_API_KEY`)




  To use the script:
  1. Add your API key to the `OPENAI_API_KEY` environment variable.
  2. Install the package using: `pip install chat-in-a-nutshell`




  This script was developed for chatting with OpenAI's ChatGPT from the comfort of the terminal. The API used in the script incurs charges (depending on its usage). For more information about pricing, refer to the OpenAI documentation.
  Please note that there is no warranty for script functionality. Also, keep in mind that it is suitable for brief and straightforward messages.




  - **o1 model support**:
    - Removed system message from requests to o1 models because they are currently not supported.
    - Set temperature to 1 for o1 models; other values are not currently supported.

  - **Added CI/CD Pipeline**:
    - Added GitHub Actions pipeline for deploying to PyPI.


  - Migrated to OpenAI v1
  - Published as PyPi package (https://pypi.org/project/chat-in-a-nutshell/)
  - Updated executable name from `chat` to `ch` to avoid conflicts with other programs.
  - Configuration file containing system message, temperature, model and conversation if in conversation mode is now saved in the home directory (`~/.chatconfig.json`).
  - Added the option to save the response as audio file to a specified path.
  - Added the option to list available OpenAI and ChatGPT models.



  - Added the option to make a new system message as default by creating a config file.
  - Added the option to select a model (`--help` now prints the list of available `gpt` models)
  - Added the option to select a temperature for a model.
  - The chatbot is now initialized as a class instance.
  - Added a flag `conversation` that enables longer conversation.



  - Initial release of the script



  Feel free to leave suggestions in the form of GitHub issues. Thank you!


pkgId: bd662d2c62770a3e1695fa200a43d51b9174acd13408496d9a379dcc405d94e8
name: python-chat-minal
arch: src
version: 1.0
epoch: 0
release: 1
summary: Chat Completion running on CLI using Language, support OpenAI and Groq
url: https://github.com/fadingNA/chat-completion-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat-minal-1.0-1.src.rpm
checksum_type: sha256
description:
  The chat-minal is a command-line tool work on terminal that makes it easy to interact with the OpenAI Chat Completion API using Langchain. This tool allows you to send text prompts and receive AI-generated responses directly from the command line. You can customize the model, set parameters like temperature and token limits, and save the output to a file.

  > Added new feature 0.1.1 pre defined prompt user can select choice for make genAI running task without input text or prompt.

  References [Langchain Document](https://api.python.langchain.com/en/latest/llms/langchain_openai.llms.base.OpenAI.html)



  Demo Link [chat-minal tutorial](https://youtu.be/NT175YPU-FY)



  <center>

  ![Code Review in Chat Completion Tool](assets/code_reviews.png)
  *Figure 1: Code Review in Chat Completion Tool*

  ![Convert JSON to CSV](assets/convert_json_tocsv.png)
  *Figure 2: Converting JSON to CSV using the Tool*

  ![Generate Markdown from Text](assets/generate_markdown.png)
  *Figure 3: Generating Markdown from Text with Ease*

  ![Summarize Text](assets/summarize_text.png)
  *Figure 4: Summarizing Text in the Chat Completion Tool*

  </center>




  This tool allows you to interact with the ChatOpenAPI from Langchain via a command-line interface (CLI). You can provide input text, specify a model, and configure other parameters to generate chat completions.

  Langchain is a Python or Javascript library that provide a flexibility to interact with OpenAI API. It allows you to generate completions for various tasks, such as chat, code, and text generation. You can use Langchain to build AI-powered applications, automate tasks, and enhance your projects with AI capabilities.

  - Embedding: Embedding is a process of converting text into a numerical representation. It is a crucial step in natural language processing (NLP) tasks, such as text classification, sentiment analysis, and named entity recognition. Embeddings capture the semantic meaning of words and sentences, enabling machine learning models to understand and process text data.

  - Vectorization: Vectorization is a process of converting text data into a numerical representation. It is a fundamental step in natural language processing (NLP) tasks, such as text classification, sentiment analysis, and named entity recognition. Vectorization transforms text data into a format that machine learning models can process and analyze.

  - RAG: Retrieval-Augmented Generation (RAG) is a model architecture that combines retrieval and generation to improve the quality of text generation tasks. RAG leverages a retriever to retrieve relevant information from a large corpus of text and a generator to generate responses based on the retrieved information. This approach enables the model to generate more accurate and contextually relevant responses.




  - Easy-to-use CLI for the ChatOpenAI Completion API from Langchain
  - Supports various models, temperature settings, and maximum token limits
  - Outputs to a specified file or a default file
  - Includes error handling and logging
  - Streaming Response
  - Selecting Models
  - Selected Choise for predefiend prompt



  1. **Clone the Repository:**

     ```bash
     git clone https://github.com/fadingNA/chat-completion-api.git
     cd chat-completion-api
     pip install -r requirements.txt # if you are using pip3 change pip to pip3 instead.

     cd app # to run the play.py file or app/play.py
     ```


  - locate to examples folder to run the bash script

    ```bash
    python3 play.py ../examples/sample2.json --api_key sk_xxx \
    
     -i "Tell me about directional derivatives" \ # input text
     --temperature 0.7 \
     --max_tokens 150 \
     --model gpt-4 \ # gpt-4o or gpt-4
     --output output.txt \

    ```



  | Option               | Description                                         |
  |----------------------|-----------------------------------------------------|
  | `-h, --help, --howto`| Show the help message.                               |
  | `-v, --version`      | Show the version of the tool.                        |
  | `--input_text, -i`   | Input text to generate completion.                   |
  | `--output, -o`       | Output file to save the generated completion.        |
  | `--temperature, -t`  | Temperature for the completion.                      |
  | `--max_tokens`       | Maximum tokens for the completion.                   |
  | `--api_key, -a`      | OpenAI API Key.                                      |
  | `--model, -m`        | Model for the completion.                            |
  | `--models`           | List all available models on OpenAI.                 |
  | `--select_choices`   | Will use a pre defined prompt                        |
  | `--token-usage`     | Token usage for the completion.                      |



  - Python 3.7+
  - An OpenAI API key




  | Name          | Blog Post (URL)                  | GitHub Repo (URL)                       | Language    |
  |---------------|---------------------------------|-----------------------------------------|-------------|
  | Nonthachai Plodthong    | [Blog Post](https://dev.to/fadingna/open-source-development-187j) | [GitHub Repo](https://github.com/fadingNA/chat-completion-api) | Python + SSH |



  This project is licensed under the MIT License - see the [LICENSE](https://github.com/fadingNA/chat-completion-api/blob/main/LICENSE) file for details.


pkgId: 3f7d0c6f4aa1a4e7fc4fa62a1c0f10ba0dce3471748fb354888d42fe0bdc6003
name: python-chat-rag
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/chat-rag/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat-rag-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This is the NLP Engine for ChatFAQ. It is divided in two modules:

  1. Information Retrieval: This module is responsible for retrieving the most relevant answer to a given question.
  2. Chatbot: This module is responsible for generating a response to the given question based on the retrieved answer and chat with the user.



  The `Retriever` is the main class for the information retrieval system. It takes as input a question (query) and a context and returns the most relevant sentences from the context to the query. This is done using embeddings and the dot product to compute the similarity between the query and the context sentences.







  The `RetrieverAnswerer` is the main class for the chatbot. It takes as input a question (query) and a context and returns a response to the query. This is done by first retrieving the most relevant sentences from the context to the query and then generating a response based on the retrieved sentences.






  add repository to poetry config

      poetry config repositories.test-pypi https://test.pypi.org/legacy/

  get token from https://test.pypi.org/manage/account/token/

  store token using

      poetry config pypi-token.test-pypi pypi-YYYYYYYY



  get token from https://pypi.org/manage/account/token/

  store token using

      poetry config pypi-token.chat-rag pypi-XXXXXXXX

  Each time you need to publish

  Bump version

      poetry version prerelease

  or

      poetry version patch

  Then build

      poetry build



  To TestPyPi

      poetry publish -r test-pypi

  To PyPi

      poetry publish


pkgId: ed2a279e83fc9b719d6bfba4d2713bc171bb5ace38fccc681dac836e756409b6
name: python-chat-with-mlx
arch: src
version: 0.2.2
epoch: 0
release: 1
url: https://pypi.org/project/chat-with-mlx/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat-with-mlx-0.2.2-1.src.rpm
checksum_type: sha256
summary:
  A Retrieval-augmented Generation (RAG) chat interface with support for multiple open-source models, designed to run natively on MacOS and Apple Silicon with MLX.

description:
  <div align="center">



  [![version](https://badge.fury.io/py/chat-with-mlx.svg)](https://badge.fury.io/py/chat-with-mlx)
  [![downloads](https://img.shields.io/pypi/dm/chat-with-mlx)](https://pypistats.org/packages/chat-with-mlx)
  [![license](https://img.shields.io/pypi/l/chat-with-mlx)](https://github.com/qnguyen3/chat-with-mlx/blob/main/LICENSE.md)
  [![python-version](https://img.shields.io/pypi/pyversions/chat-with-mlx)](https://badge.fury.io/py/chat-with-mlx)
  </div>

  An all-in-one Chat Playground using Apple MLX on Apple Silicon Macs.

  ![chat_with_mlx](assets/Logo.png)



  - **Privacy-enhanced AI**: Chat with your favourite models and data securely.
  - **MLX Playground**: Your all in one LLM Chat UI for Apple MLX
  - **Easy Integration**: Easy integrate any HuggingFace and MLX Compatible Open-Source Models.
  - **Default Models**: Llama-3, Phi-3, Yi, Qwen, Mistral, Codestral, Mixtral, StableLM (along with Dolphin and Hermes variants)





  - Install Pip
  - Install: `pip install chat-with-mlx`



  ```bash
  git clone https://github.com/qnguyen3/chat-with-mlx.git
  cd chat-with-mlx
  python -m venv .venv
  source .venv/bin/activate
  pip install -e .
  ```



  ```bash
  git clone https://github.com/qnguyen3/chat-with-mlx.git
  cd chat-with-mlx
  conda create -n mlx-chat python=3.11
  conda activate mlx-chat
  pip install -e .
  ```



  - Start the app: `chat-with-mlx`



  Please checkout the guide [HERE](ADD_MODEL.MD)



  - When the model is downloading by Solution 1, the only way to stop it is to hit `control + C` on your Terminal.
  - If you want to switch the file, you have to manually hit STOP INDEXING. Otherwise, the vector database would add the second document to the current database.
  - You have to choose a dataset mode (Document or YouTube) in order for it to work.
  - **Phi-3-small** can't do streaming in completions



  MLX is an array framework for machine learning research on Apple silicon,
  brought to you by Apple machine learning research.

  Some key features of MLX include:

  - **Familiar APIs**: MLX has a Python API that closely follows NumPy.  MLX
     also has fully featured C++, [C](https://github.com/ml-explore/mlx-c), and
     [Swift](https://github.com/ml-explore/mlx-swift/) APIs, which closely mirror
     the Python API.  MLX has higher-level packages like `mlx.nn` and
     `mlx.optimizers` with APIs that closely follow PyTorch to simplify building
     more complex models.

  - **Composable function transformations**: MLX supports composable function
     transformations for automatic differentiation, automatic vectorization,
     and computation graph optimization.

  - **Lazy computation**: Computations in MLX are lazy. Arrays are only
     materialized when needed.

  - **Dynamic graph construction**: Computation graphs in MLX are constructed
     dynamically. Changing the shapes of function arguments does not trigger
     slow compilations, and debugging is simple and intuitive.

  - **Multi-device**: Operations can run on any of the supported devices
     (currently the CPU and the GPU).

  - **Unified memory**: A notable difference from MLX and other frameworks
     is the *unified memory model*. Arrays in MLX live in shared memory.
     Operations on MLX arrays can be performed on any of the supported
     device types without transferring data.



  I would like to send my many thanks to:

  - The Apple Machine Learning Research team for the amazing MLX library.
  - LangChain and ChromaDB for such easy RAG Implementation
  - All contributors



  [![Star History Chart](https://api.star-history.com/svg?repos=qnguyen3/chat-with-mlx&type=Date)](https://star-history.com/#qnguyen3/chat-with-mlx&Date)


pkgId: 2ade0da2a441d8d548ff3961909b78805c3a84b6c2db86fbc4b31443758b511a
name: python-chat2edit
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: A small example package
url: https://github.com/nghialt3670/chat2edit-python
rpm_license: CC BY-NC 4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat2edit-0.0.6-1.src.rpm
checksum_type: sha256
description:
  Chat2Edit is a Python package designed for editing files collaboratively with AI assistance. It provides tools to enhance productivity and streamline workflows.



  - AI-powered file editing
  - Seamless collaboration
  - Easy-to-use API



  Install Chat2Edit using pip:

  ```bash
  pip install chat2edit


pkgId: a8d5bad069f14bdf52441b00ba79e31b0def8fe0f966c694fc2143ec7ebb44e6
name: python-chat2plot
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: chat to visualization with LLM
url: https://github.com/nyanp/chat2plot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chat2plot-0.0.11-1.src.rpm
checksum_type: sha256
description:
  This library uses LLMs to generate:

  1. Visualization
  2. High-level chart specifications in json (You can choose between a simple or vega-lite format)
  3. Explanation

  from natural language requests for given data.

  Chat2Plot does not generate executable code or SQL from the LLM,
  so you can safely generate visualizations.

  demo: https://chat2plot-sample.streamlit.app/

  ![sample](sample.png)



  ```shell
  pip install chat2plot
  ```

  ```Python
  import os
  import pandas as pd
  from chat2plot import chat2plot


  os.environ["OPENAI_API_KEY"] = "..."

  df = pd.read_csv(...)


  c2p = chat2plot(df)


  result = c2p("average target over countries")
  result.figure.show()  # draw a plot
  print(result.config)  # get a config (json / dataclass)
  print(result.explanation)  # see the explanation generated by LLM


  result = c2p("change to horizontal-bar chart")
  result.figure.show()
  ```



  Inside Chat2Plot, LLM does not generate Python code,
  but generates plot specifications in json.

  The declarative visualization specification in json is transformed into actual charts in
  Chat2Plot using plotly or altair, but users can also use json directly in their own applications.

  This design limits the visualization expression compared to Python code generation
  (such as ChatGPT's Code Interpreter Plugin), but has the following practical advantages:

  - Secure
      - More secure execution, as LLM does not directly generate code.

  - Language-independent
      - Declarative data structures are language-agnostic, making it easy to plot in non-Python environments.

  - Interactive
      - Declarative data can be modified by the user to improve plots through collaborative work between the user and LLM.

  By default, chat2plot uses [function calling API](https://openai.com/blog/function-calling-and-other-api-updates).




  `gpt-3.5-turbo-0613` is used by default, but you can use other language models.

  ```python
  import pandas as pd
  from langchain.chat_models import AzureChatOpenAI
  from chat2plot import chat2plot

  plot = chat2plot(pd.DataFrame(), chat=AzureChatOpenAI())
  ret = plot.query("<your query>")
  ```



  ```python
  import pandas as pd
  from chat2plot import chat2plot

  plot = chat2plot(pd.DataFrame(), schema_definition="vega")
  ret = plot.query("<your query>")

  assert isinstance(ret.config, dict)  # vega-lite format
  print(ret.config)
  ```



  ```python
  import pydantic
  import pandas as pd
  from chat2plot import chat2plot

  class CustomChartConfig(pydantic.BaseModel):
      chart_type: str
      x_axis_name: str
      y_axis_name: str
      y_axis_aggregate: str

  plot = chat2plot(pd.DataFrame(), schema_definition=CustomChartConfig)
  ret = plot.query("<your query>")


  assert isinstance(ret.config, CustomChartConfig)
  ```


  You can specify in which language the chart explanations should be output.
  If not specified, it will return as much as possible in the same language as the user's question,
  but this option is often useful if you always want output in a specific language.

  ```python
  import pandas as pd
  from chat2plot import chat2plot

  plot = chat2plot(pd.DataFrame(), language="Chinese")
  ret = plot.query("<your query>")

  print(ret.explanation)  # explanation
  ```


  When `description_strategy="dtypes"` is specified, chat2plot will not send the data
  content (but just column names) to LLM.

  ```python
  import pandas as pd
  from langchain.chat_models import AzureChatOpenAI
  from chat2plot import chat2plot

  plot = chat2plot(pd.DataFrame(), description_strategy="dtypes")
  ret = plot.query("<your query>")
  ```




  A `Chat2Plot` instance can be created using the `chat2plot` function.

  ```Python
  def chat2plot(
      df: pd.DataFrame,
      schema_definition: Literal["simple", "vega"] | Type[pydantic.BaseModel] = "simple",
      chat: BaseChatModel | None = None,
      function_call: bool | Literal["auto"] = "auto",
      language: str | None = None,
      description_strategy: str = "head",
      custom_deserializer: ModelDeserializer | None = None,
      verbose: bool = False,
  ) -> Chat2PlotBase:
  ```

  - **df** - Data source for visualization.
  - **schema_definition** (optional) - Type of json format.
    - `vega` - A vega-lite compliant format
    - `simple` - chat2plot's built-in format, parsed as `chat2plot.PlotConfig`

    If you want chat2plot to generate chart definitions according to your own defined schema,
    you can pass any type that extends pydantic.BaseModel instead of these two options.
  - **chat** (optional) - The chat instance for interaction with LLMs.
    If omitted, `ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo-0613")` will be used.
  - **function_call** (optional) - Specifies whether to use the [function calling API](https://openai.com/blog/function-calling-and-other-api-updates).
    If omitted, it is automatically determined based on the underlying model type.
  - **language** (optional) - Language of explanations. If not specified, it will be automatically inferred from user prompts.
  - **description_strategy** (optional) - Type of how the information in the dataset is embedded in the prompt.
    - `head` - send `df.head(5)` to LLMs.
    - `dtypes` - send `df.dtypes` to LLMs. This can be used when you do not want to send contents of `df` to LLMs.
  - **custom_deserializer** (optional) - Specifies a custom deserializer to convert json returned from the LLM into a chart configuration.
  - **verbose** (optional) - If `True`, chat2plot will output logs.


  Once an instance is created, a graph generation request can be made
  by calling `query` method, or simply passing the same arguments to the instance (`__call__`).

  ```Python
  def query(self, q: str, config_only: bool = False, show_plot: bool = False) -> Plot:
  ```
  - **q** - A query string.
  - **config_only** - If `True`, skip generating figure.
  - **show_plot** - If `True`, showing the generated figure is also performed inside chat2plot.

  The default behavior is `config_only=False` and `show_plot=False`,
  i.e. Chat2Plot generates a figure as well as configuration, but does not draw it.

  The `query` method returns `Plot` object, and this has the following properties:

  ```Python
  @dataclass(frozen=True)
  class Plot:
      figure: alt.Chart | Figure | None
      config: PlotConfig | dict[str, Any] | None
      response_type: ResponseType
      explanation: str
      conversation_history: list[langchain.schema.BaseMessage] | None
  ```

  - **figure** - The generated figure (chart).
  - **config** - The chart specification. Returns dict for `vega` mode and `PlotConfig` for `simple` mode.
  - **response_type** - The result code of the response.
  - **explanation** - Reason for the chart setup, generated by LLMs.
  - **conversation_history** - Full history of conversation (including retry prompt).


pkgId: a6b64d5770fef1902d55b73bd548092fa3688d4990a3ef8db991fe4350f8ec1d
name: python-chatarena
arch: src
version: 0.1.18
epoch: 0
release: 1
summary: Multi-Agent Language Game Environments for Large Language Models
url: https://github.com/chatarena/chatarena
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatarena-0.1.18-1.src.rpm
checksum_type: sha256
description:
  ChatArena is a library that provides multi-agent language game environments and facilitates research about autonomous
  LLM agents and their social interactions.
  It provides the following features:
  - **Abstraction**: it provides a flexible framework to define multiple players, environments and the interactions
    between them, based on Markov Decision Process.
  - **Language Game Environments**: it provides a set of environments that can help understanding, benchmarking or
    training agent LLMs.
  - **User-friendly Interfaces**: it provides both Web UI and CLI to develop/prompt engineer your LLM agents to act in
    environments.
  ![ChatArena Architecture](docs/images/chatarena_architecture.png)

  **Try our online demo:**
  [![demo](https://img.shields.io/badge/Demo-Huggingface%F0%9F%A4%97%20Space-orange?style=flat)](https://chatarena-chatarena-demo.hf.space)
  [![Demo video](https://img.shields.io/badge/Video-Vimeo-blue?logo=vimeo)](https://vimeo.com/816979419)

  Requirements:
  - Python >= 3. 7
  - OpenAI API key (optional, for using GPT-3.5-turbo or GPT-4 as an LLM agent)
  Install with pip:
  ```bash
  pip install chatarena
  ```
  or install from source:
  ```bash
  pip install git+https://github.com/chatarena/chatarena
  ```
  To use GPT-3 as an LLM agent, set your OpenAI API key:
  ```bash
  export OPENAI_API_KEY="your_api_key_here"
  ```

  By default `pip install chatarena` will only install dependencies necessary for ChatArena's core functionalities.
  You can install optional dependencies with the following commands:
  ```bash
  pip install chatarena[all_backends] # install dependencies for all supported backends: anthropic, cohere, huggingface, etc.
  pip install chatarena[all_envs]     # install dependencies for all environments, such as pettingzoo
  pip install chatarena[all]          # install all optional dependencies for full functionality
  ```

  The quickest way to see ChatArena in action is via the demo Web UI.
  To launch the demo on your local machine, you first pip install chatarena with extra gradio dependency, then git clone
  this repository to your local folder, and finally call the `app.py` in the root directory of the repository:
  ```shell
  pip install chatarena[gradio]
  git clone https://github.com/chatarena/chatarena.git
  cd chatarena
  gradio app.py
  ```
  This will launch a demo server for ChatArena, and you can access it from your browser (port 8080).
  [//]: # (The interface looks like this:)
  [//]: # (![webui screenshot]&#40;docs/images/webui.png&#41;)
  Check out this video to learn how to use Web UI: [![Webui demo video](https://img.shields.io/badge/WebUI%20Demo%20Video-Vimeo-blue?logo=vimeo)](https://vimeo.com/816979419)

  For an introduction to the ChatArena framework, please refer to [this document](docs/devdoc/design.md).
  For a walkthrough of building a new environment, check [![Open In Colab](https://img.shields.io/badge/Colab-Open%20Notebook-blue?logo=google-colab)](https://colab.research.google.com/drive/1vKaskNMBtuGOVgn8fQxMgjCevn2wp1Ml?authuser=0#scrollTo=P5DCC0Y0Zbxi)
  Here we provide a compact guide on minimal setup to run the game and some general advice on customization.

  1. **Arena**: Arena encapsulates an environment and a collection of players. It drives the main loop of the game and
     provides HCI utilities like webUI, CLI, configuration loading and data storage.
  2. **Environment**: The environment stores the game state and executes game logics to make transitions between game
     states. It also renders observations for players, the observations are natural languages.
      1. The game state is not directly visible to the players. Players can only see the observations.
  3. **Language Backend**: Language backends are the source of language intelligence. It takes text (or collection of
     text) as input and returns text in response.
  4. **Player**: The player is an agent that plays the game. In RL terminology, it’s a policy, a stateless function
     mapping from observations to actions.

  Load `Arena` from a config file -- here we use `examples/nlp-classroom-3players.json` in this repository as an example:
  ```python
  arena = Arena.from_config("examples/nlp-classroom-3players.json")
  arena.run(num_steps=10)
  ```
  Run the game in an interactive CLI interface:
  ```python
  arena.launch_cli()
  ```
  Check out this video to learn how to use
  CLI: [![cli demo video](https://img.shields.io/badge/CLI%20Demo%20Video-Vimeo-blue?logo=vimeo)](https://vimeo.com/816989884)
  A more detailed guide about how to run the main interaction loop with finer-grained control can be
  found [here](docs/devdoc/mainloop.md)

  1. **Arena**: Overriding Arena basically means one is going to write their own main loop. This can allow different
     interaction interfaces or drive games in a more automated manner, for example, running an online RL training loop
  2. **Environment**: A new environment corresponds to a new game, one can define the game dynamics here with hard-coded
     rules or a mixture of rules and language backend.
  3. **Backend**: If one needs to change the way of formatting observations (in terms of messages) into queries for the
     language model, the backend should be overridden.
  4. **Player**: By default, when a new observation is fed, players will query the language backend and return the
     response as actions. But one can also customize the way that players are interacting with the language backend.

  You can define your own environment by extending the `Environment` class. Here are the general steps:
  1. Define the class by inheriting from a base class and setting `type_name`, then add the class
     to [`ALL_ENVIRONMENTS`](chatarena/environments/__init__.py#L17)
  2. Initialize the class by defining `__init__` method (its arguments will define the corresponding config) and
     initializing class attributes
  3. Implement game mechanics in methods `step`
  4. Handle game states and rewards by implementing methods such as `reset`, `get_observation`, `is_terminal`,
     and `get_rewards`
  5. Develop role description prompts (and a global prompt if necessary) for players using CLI or Web UI and save them to
     a
     config file.
  We provide [a detailed tutorial](docs/tutorials/create_your_environment.md) to demonstrate how to define a custom
  environment,
  using the [`Chameleon` environment](chatarena/environments/chameleon.py) as example.
  If you want to port an existing library's environment to ChatArena, check
  out [`PettingzooChess` environment](chatarena/environments/pettingzoo_chess.py) as an example.


  A multi-player language game environment that simulates a
  conversation.
  * [NLP Classroom](examples/nlp-classroom-3players.json): a 3-player language game environment that simulates a
    classroom
    setting. The game is played in turns, and each turn a player can either ask a question or answer a question.
    The game ends when all players have asked and answered all questions.

  Based on conversation, but with a moderator that controls the game dynamics.
  * [Rock-paper-scissors](examples/rock-paper-scissors.json): a 2-player language game environment that simulates a
    rock-paper-scissors game with moderator conversation.
    Both player will act in parallel, and the game ends when one player wins 2 rounds.
  * [Tic-tac-toe](examples/tic-tac-toe.json): a 2-player language game environment that simulates a tic-tac-toe
    game with moderator conversation.
    The game is played in turns, and each turn a player can either ask for a move or make a move. The game ends when
    one
    player wins or the board is full.

  A multi-player social deduction game. There are two roles in the game, chameleon and non-chameleon.
  The topic of the secret word will be first revealed to all the players.
  Then the secret word will be revealed to non-chameleons.
  The chameleon does not know the secret word.
  The objective in the game depends on the role of the player:
  - If you are not a chameleon, your goal is to reveal the chameleon without exposing the secret word.
  - If you are a chameleon, your aim is to blend in with other players, avoid being caught, and figure out the secret
    word.
    There are three stages in the game:
  1. The giving clues stage: each player will describe the clues about the secret word.
  2. The accusation stage: In this stage, each player will vote for another player who is most likely the chameleon. The
     chameleon should vote for other players.
  3. The guess stage: If the accusation is correct, the chameleon should guess the secret word given the clues revealed by
     other players.

  A two-player chess game environment that uses the PettingZoo Chess environment.

  A two-player tic-tac-toe game environment that uses the PettingZoo TicTacToe environment. Differing from the
  `Moderator Conversation` environment, this environment is driven by hard-coded rules rather than a LLM moderator.

  We welcome contributions to improve and extend ChatArena. Please follow these steps to contribute:
  1. Fork the repository.
  2. Create a new branch for your feature or bugfix.
  3. Commit your changes to the new branch.
  4. Create a pull request describing your changes.
  5. We will review your pull request and provide feedback or merge your changes.
  Please ensure your code follows the existing style and structure.

  If you find ChatArena useful for your research, please cite our repository (our arxiv paper is coming soon):
  ```bibtex
  @software{ChatArena,
    author = {Yuxiang Wu, Zhengyao Jiang, Akbir Khan, Yao Fu, Laura Ruis, Edward Grefenstette, and Tim Rocktäschel},
    title = {ChatArena: Multi-Agent Language Game Environments for Large Language Models},
    year = {2023},
    publisher = {GitHub},
    journal = {GitHub repository},
    version = {0.1},
    howpublished = {\url{https://github.com/chatarena/chatarena}},
  }
  ```

  If you have any questions or suggestions, feel free to open an issue or submit a pull request.
  You can also contact us on the Farama discord server- https://discord.gg/Vrtdmu9Y8Q
  Happy chatting!

  We would like to thank our sponsors for supporting this project:
  - [SEQUOIA](https://www.sequoiacap.com/)
  - [Shixiang Capital](https://sx.shixiangcap.com/home)


pkgId: 6f213e93a51e3502266850c248ae1ee834c71170da52749e829743a0f2d059f4
name: python-chatbees-python-client
arch: src
version: 1.2.8
epoch: 0
release: 1
summary: Python client for ChatBees
url: https://pypi.org/project/chatbees-python-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatbees-python-client-1.2.8-1.src.rpm
checksum_type: sha256
description:
  Python client for [ChatBees](http://www.chatbees.ai), a Serverless Platform for your LLM Apps. ChatBees provides simple and scalable APIs, enabling you to craft a LLM app for your knowledge base in mere minutes.

  We're actively improving the product and releasing new features, and we'd love to hear your feedback!
  Please take a moment to fill out this [feedback form](https://forms.gle/pif6Vx2LqPjW5v4w5) to help us understand your use-case better.

  Signup with your Google or Microsoft account on https://www.chatbees.ai.

  ChatBees python client provides very simple APIs for you to directly upload files, crawl websites, ingest data sources including Confluence, Notion and Google Drive. Then you can simply ask questions.




  You can try out ChatBees in just a few lines of code. You can create your own collections, upload files, then get answers  specific to your data assets. The following example walks you through the process of creating a collection and indexing [the original transformer paper](https://arxiv.org/abs/1706.03762) into that collection.

  ```python
  import chatbees as cb



  cb.init(api_key=my_api_key, account_id=your_account_id)


  llm_research = cb.Collection(name="llm_research")
  cb.create_collection(llm_research)


  llm_research.upload_document("https://arxiv.org/pdf/1706.03762.pdf")


  llm_research.ask("what is a transformer?")

  ```



  Install a released ChatBees python client from pip.

  python3 version ```>= 3.10``` is required

  ```shell
  pip3 install chatbees-python-client
  ```



  In the following examples, we will assume you have signup with your google account.


  You can create a collection that is only accessible with a specific API key.

  ```python
  import chatbees as cb

  cb.init(api_key=my_api_key, account_id=your_account_id)


  collection = cb.Collection(name='llm_research')
  cb.create_collection(collection)
  ```


  You can see list of collections you have access to. For example, this list
  will include all collections that were created using the currently configured
  API key.

  ```python
  import chatbees as cb

  cb.init(api_key=my_api_key, account_id=your_account_id)

  collections = cb.list_collections()
  ```



  You can upload a local file or a file from a web URL and index it into a
  collection.

  **Supported file format**
  - ```.pdf``` PDF files
  - ```.csv``` CSV files
  - ```.txt``` Plain-text files
  - ```.md```  Markdown files
  - ```.docx``` Microsoft word documents

  ```python
  import chatbees as cb

  cb.init(api_key=my_api_key, account_id=your_account_id)


  collection = cb.collection('llm_research')



  collection.upload_document('/path/to/file.pdf')
  collection.upload_document('https://path/to/file.pdf')
  ```


  You can pass the website root url. ChatBees will automatically crawl it.

  ```python
  import chatbees as cb

  cb.init(api_key=my_api_key, account_id=your_account_id)


  collection = cb.Collection(name='example-web')
  cb.create_collection(collection)

  root_url = 'https://www.example.com'
  crawl_id = collection.create_crawl(root_url)


  resp = collection.get_crawl(crawl_id)


  collection.delete_crawl(root_url)


  collection.index_crawl(crawl_id)
  ```


  You can ask questions within a collection. API key is required for private
  collections only. ```ask()``` method returns a plain-text answer to
  your question, as well as a list of most relevance references used to derive
  the answer.

  ```python
  import chatbees as cb

  cb.init(api_key=my_api_key, account_id=your_account_id)



  answer, refs = cb.collection('llm_research').ask('what is a transformer?')
  ```


  You can delete a collection using the same API key that was used to create it.

  ```python
  import chatbees as cb

  cb.init(api_key=my_api_key, account_id=your_account_id)

  cb.delete_collection('llm_research')
  ```


pkgId: 68727a4eef635239d9370737ffe2e6e2d15d70a51b6ff997240f4e6af86a5cc4
name: python-chatblade
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: CLI Swiss Army Knife for ChatGPT
url: https://github.com/npiv/chatblade
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatblade-0.7.0-1.src.rpm
checksum_type: sha256
description:
  query
  ```

  Sessions are named conversations.
  If you start chatblade with a session name SESS of your choice:
  ```bash
  chatblade -S SESS can we make a gif instead from 00:22:01 to 00:22:04
  ```
  chatblade will create a session called SESS if it does not exist, and it will store the current exchange (query-response pair) for SESS.
  If such a session already exists, the saved conversation will be loaded and the new exchange will be appended.
  Without a session argument, the exchange also gets stored in a session named `last`; however, subsequent sessionless invocation will overwrite the content of `last`. (You can continue a conversation that was started as a sessionless exchange by passing `-S last`, but `last` won't be a safe space for keeping a conversation, as the next sessionless invocation will clear it again.) The `-l` option is provided as a shorthand for `-S last`.
  If you specify a session without a query:
  ```bash
  chatblade -S SESS
  ```
  chatblade will recall the conversation without modifying the session.
  chatblade supports various operations on sessions. It provides the `--session-OP` options, where `OP` can be `list`, `path`, `dump`, `delete`, `rename`.

  If you want to check the approximate cost and token usage of a previous query, you can use the `-t` flag for "tokens."
  We could do this when passing in a lot of context like in the example above for instance.
  ```bash
  curl https://news.ycombinator.com/rss | chatblade given the above rss can you show me the top 3 articles about AI and their links -t
  ```
  <img width="650" alt="image" src="https://user-images.githubusercontent.com/452020/226874588-28c53f53-1d19-4ce3-b7ec-b01c2f7cf75a.png">
  This won't perform any action over the wire, and just calculates the tokens locally.

  The system message is used to instruct the model how to behave, see [OpenAI - Instructing Chat Models](https://platform.openai.com/docs/guides/chat/instructing-chat-models).
  These can be loaded with `-p`. For convenience any file we place under ~/.config/chatblade/ will be picked up by this command.
  So for example, given the following file `~/.config/chatblade/etymology`, which contains:
  ```
  I want you to act as a professional Etymologist and Quiz Generator. You have a deep knowledge of etymology and will be provided with a word.
  The goal is to create cards that quiz on both the etymology and finding the word by its definition.
  The following is what a perfect answer would look like for the word "disparage":
  [{
    "question": "A verb used to indicate the act of speaking about someone or something in a negative or belittling way.<br/> <i>E.g He would often _______ his coworkers behind their backs.</i>",
    "answer": "disparage"
  },
  {
    "question": "What is the etymological root of the word disparage?",
    "answer": "From the Old French word <i>'desparagier'</i>, meaning 'marry someone of unequal rank', which comes from <i>'des-'</i> (dis-) and <i>'parage'</i> (equal rank)"
  }]
  You will return answers in JSON only. Answer truthfully and if you don't know then say so. Keep questions as close as possible to the
  provided examples. Make sure to include an example in the definition question. Use HTML within the strings to nicely format your answers.
  If multiple words are provided, create questions and answers for each of them in one list.
  Only answer in JSON, don't provide any more text. Valid JSON uses "" quotes to wrap its items.
  ```
  We can now run a command and refer to this prompt with `-p etymology`:
  ```bash
  chatblade -p etymology gregarious
  ```
  You can also point -p to a file path directly to load a system message from any arbitrary location
  <img src="assets/example5.png">
  And since we asked for JSON, we can pipe our result to something else, e.g.:
  ```bash
  chatblade -l -e > toanki
  ```

  chatblade can be used with an Azure OpenAI endpoint, in which case in addition to the `OPENAI_API_KEY` you'll need to set the following environment variables:
  - `OPENAI_API_TYPE` :: Set to `azure`. As required by [openai-python](https://github.com/openai/openai-python)
  - `AZURE_OPENAI_ENDPOINT` :: URL to your cognitive services' endpoint, e.g. `https://eastus.api.cognitive.microsoft.com/`. Please note this is a *breaking change* introduced by `openai-python` and the previous environment variable name is `OPENAI_API_BASE`
  - `OPENAI_API_AZURE_ENGINE` :: name of your deployment in Azure, f.e. `my-gpt-35-turbo` (maps to a specific model)
  *Note*: that this will override any option for `-c 3.5` or `-c 4` which don't make sense in this case.

  ```
  usage: Chatblade [-h] [--openai-api-key key] [--openai-base-url key] [--temperature t] [-c CHAT_GPT] [-i] [-s] [-t] [--version] [-p name] [-e] [-r] [-n] [-o] [--theme theme] [-l]
                   [-S sess] [--session-list] [--session-path] [--session-dump] [--session-delete] [--session-rename newsess]
                   [query ...]
  a CLI Swiss Army Knife for ChatGPT
  positional arguments:
    query                            Query to send to chat GPT
  options:
    -h, --help                       show this help message and exit
    --openai-api-key key             the OpenAI API key can also be set as env variable OPENAI_API_KEY
    --openai-base-url key            A custom url to use the openAI against a local or custom model, eg ollama
    --temperature t                  temperature (openai setting)
    -c CHAT_GPT, --chat-gpt CHAT_GPT
                                     chat GPT model use either the fully qualified model name, or 3.5 (gpt-3.5-turbo), 4 (gpt-4), 4t (gpt-4-turbo), 4o (gpt-4o), mini (gpt-4o-mini),
                                     o1 (o1-preview), o1mini (o1-mini). Can also be set via env variable OPENAI_API_MODEL
    -i, --interactive                start an interactive chat session. This will implicitly continue the conversation
    -s, --stream                     Stream the incoming text to the terminal
    -t, --tokens                     display what *would* be sent, how many tokens, and estimated costs
    --version                        display the chatblade version
    -p name, --prompt-file name      prompt name - will load the prompt with that name at ~/.config/chatblade/name or a path to a file
  result formatting options:
    -e, --extract                    extract content from response if possible (either json or code block)
    -r, --raw                        print session as pure text, don't pretty print or format
    -n, --no-format                  do not add pretty print formatting to output
    -o, --only                       Only display the response, omit query
    --theme theme                    Set the theme for syntax highlighting see https://pygments.org/styles/, can also be set with CHATBLADE_THEME
  session options:
    -l, --last                       alias for '-S last', the default session if none is specified
    -S sess, --session sess          initiate or continue named session
    --session-list                   list sessions
    --session-path                   show path to session file
    --session-dump                   dump session to stdout
    --session-delete                 delete session
    --session-rename newsess         rename session
  ```


pkgId: a8460b572513616abe92caae1e9c2b78ede642682601aeee3c9041898e6c18d4
name: python-chatbot-webraft
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A package for building chatbots easily without needing of any high system resources.
url: https://pypi.org/project/chatbot-webraft/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatbot-webraft-1.0.2-1.src.rpm
checksum_type: sha256
description:
  The "chatbot-webraft" Python module is a powerful tool that allows users to create their own chatbots with custom datasets in an easy and efficient manner.
  It is designed to work with CSV datasets and provides a variety of model types to choose from, ensuring that users can select the best model for their specific needs.
  The module requires no high-end servers and can be used with or without training, making it a flexible and cost-effective solution for chatbot development.
  With the "chatbot-webraft" module, users can quickly and easily develop their own chatbots, customizing the dataset and model type to fit their specific requirements.
  Whether you're a beginner or an experienced developer, the "chatbot-webraft" module provides a simple and intuitive way to create custom chatbots with Python due to its easy to use syntax.

  One of the best features of Chatbot-Webraft is its ability to generate code scripts in specific programming languages from text. This means that you can use your preferred programming language,
  or even write your own code, and Chatbot-Webraft will convert it into a script that is ready to use. Whether you are an experienced developer or just starting out, this feature makes it easy to
  build chatbots quickly and efficiently.

  In summary, Chatbot-Webraft is a must-have tool for anyone looking to create chatbots. With its wide range of features, including multiple model types, easy customization, and code generation capabilities,
  Chatbot-Webraft is the perfect tool for anyone looking to build chatbots with ease and efficiency.

  **PLEASE NOTE THAT THIS MODULE IS IN BETA AND CHATBOTS CREATED WITH IT MAY RESPOND WITH UNEXPECTED ANSWERS**



  ```from chatbot_webraft import chatbot```


  ```chatbot.create_model("my-model")```


  ```chatbot.dataset(CSV_FILE_NAME,'input','label',"my-model"") ```


  ```chatbot.add_data("my-model"",["input1","input2"],["output1","output2"]) ```


  ```input = "hi"``` / ```input = input("Enter: ")```

  ```print(chatbot.model_load(MDDEL_TYPE,input,"my-model",MDDEL_TYPE))```/```chatbot.model_load(MDDEL_TYPE,input,"my-model",MDDEL_TYPE)```

  ```print(codewriter("python",input,"my-model","pywriter")``` / ```chatbot.model_load("pywriter",input,"my-model","pywriter")```


  Inbuilt model types: nlpm (Generative, Best) , spimx (better), spimxr (more good), spim (good), rasv (not that good)

  You can use other model types by downloading them from [here]("https://models.chatbot.webraft.in") and define path where modeltype (.wrmodel) file is stored to MODEL_TYPE

  NLPM: A generative model type (framework) , works best for generative bots . (BETA)
  NLPM USAGE: ```chatbot.model_load("nlpm",input,"my-model",MODELTYPE)``` - Replace `MODELTYPE` with the other modeltype that suites you the best , i.e - spim , spimx , rasv , spim (do not replace MODELTYPE with 'nlpm' rather replace with others)

  There is also a transformer modified framework that uses Tokenizers from prebuilt transfomer model i.e - BERT . Note that it needs very high system for running and takes a lot of time to load. USE - ```chatbot.model_load("bert",input,"my-model","bert)``` (It doesnt need training)

   ```
   
  from chatbot_webraft import chatbot


  model = "my-model"


  chatbot.create_model(model)


  chatbot.dataset(CSV_FILE_NAME,INPUT_COLUMN,LABEL_COLUMN,model)



  while True:
    prompt = input("You: ")
    
    print("Bot: ",chatbot.model_load("spimx",prompt,model,"spimx"))

   ```

   
  ```

  from chatbot_webraft import chatbot
  import discord
  client = discord.Client(intents=discord.Intents.all())


  model = "my-model" #set model name
  chatbot.create_model(model) #create model
  chatbot.dataset(CSV_FILE_NAME,INPUT_COLUMN,LABEL_COLUMN,model) #load CSV dataset .. Mention input column (question) and label column (answer)
  chatbot.add_data(model,["hey","what about you"],["hello bro","im fine ,you?"]) #add more data to model (Not saved , only in memory). Data that you may want to add later.
  @client.event
  async def on_message(message):
      if message.author == client.user:
          return

      prompt = message.content

      await message.reply(chatbot.model_load("spim",prompt,model,"spim")) #run model and parse output
  client.run(BOT_TOKEN)
  ```

  ```
   
  from chatbot_webraft import chatbot


  model = "my-model"


  chatbot.create_model(model)


  chatbot.dataset(CSV_FILE_NAME,INPUT_COLUMN,LABEL_COLUMN,model)



  while True:
    prompt = input("You: ")
    
    print("Bot: ",chatbot.model_load("pywriter",prompt,model,"pywriter")) #Or codewriter("python",prompt,model,"pywriter")
  ```


  In versions < 1.0.0 you can now train / finetune your own language models through minimal code.

  Here is a basic example of pre training on chat data (using language data is advised):
  **Before trying, download the sample dataset given below. (after the code)**

  ```
  from chatbot_webraft.yourmodel import TransformerModel
  import torch

  d_model = 128 # Adjust according to your needs and system specs

  dataset_name = "sample.csv"  # Replace with your correct dataset path

  input_set = "input"

  label_set = "label"

  batch_size = 16 # Adjust according to your needs and system specs

  heads = 16 # Adjust according to your needs and system specs

  num_layers = 6 # Adjust according to your needs and system specs

  device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

  epochs = 40

  path = "path/to/folder/" # Eg. D:/Softwares/AI/Trainer/

  model_name= path+"yourmodelname" # Eg. chatllm
  transformer_model = TransformerModel(d_model, dataset_name, input_set, label_set, batch_size, heads, num_layers, device, epochs, model_name, max_len=256)
  transformer_model.train() # Finally training

  question = "hi"

  print(transformer_model.inference(question)) # Doing Inference
  ```

  You can also do inference already trained model but you require to initialise transformer model with that checkpoint and use same parameters (i.e. d_model, heads, num_layers, max_len)

  ```
  checkpoint = torch.load(path+model_name+"_final.pth",map_location=device)
  transformer = checkpoint['transformer']
  transformer_model = TransformerModel(d_model, dataset_name, input_set, label_set, batch_size, heads, num_layers, device, epochs, model_name, max_len=256,transformer=transfromer)
  ```

  You can also fine tune the model by just changing the dataset_name at initialising of new model and doing `transformer_model.finetune()`.



  Download Sample csv dataset from [here](https://webraft.in/sample.csv) , Dont forget to put the file in your project directory
  <br>
  Change `CSV_FILE_NAME` to "sample.csv" , `INPUT_COLUMN` to "input" , `LABEL_COLUMN` to "label" in the code


  Error 1 - This error indicates that the model name used in specific function is not same as the modelname set with chatbot.createmodel()
  <br>
  Error 2 - This error indicates that the codewriter couldn't convert specific text to code due to lack of resources
  <br>
  Error 3 - This error indicates that the file being set in any of these functions: chatbot.dataset() , chatbot.model_load() doesn't exist

rpm_license:
  MIT License  Copyright (c) 2024 Webraft_ChatBot  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: 23dda948a03c440250203fe02c8ca55e93730be844db0f143c390ed2fe6b87ba
name: python-chatchat
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Large Language Model API
url: https://github.com/JiauZhang/chatchat
rpm_license: GPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatchat-0.1.7-1.src.rpm
checksum_type: sha256
description:
  - ✅ 百度文心一言/ERNIE
  - ✅ 阿里通义千问/QWen
  - ✅ 讯飞星火大模型/Spark
  - ✅ 腾讯混元大模型/Hunyuan
  - ✅ DeepSeek
  - ✅ 智谱/ChatGLM


  ```shell
  pip install chatchat
  ```


  ```shell


  chatchat config tencent.secret_id=YOUR_SECRET_ID
  chatchat config tencent.secret_key=YOUR_SECRET_KEY

  chatchat config baidu.api_key=YOUR_API_KEY
  chatchat config baidu.secret_key=YOUR_SECRET_KEY

  chatchat config --list
  ```
  > Refer to [\[examples\]](./examples)


  <table align="center">
      <thead>
          <tr>
              <th colspan="2">公众号</th>
          </tr>
      </thead>
      <tbody align="center" valign="center">
          <tr>
              <td colspan="2"><img src="https://www.chatqkv.com/ghstatic/images/ofa_m.png" style="height: 196px" alt="AliPay.png"></td>
          </tr>
      </tbody>
      <thead>
          <tr>
              <th>AliPay</th>
              <th>WeChatPay</th>
          </tr>
      </thead>
      <tbody align="center" valign="center">
          <tr>
              <td><img src="https://www.chatqkv.com/AliPay.png" style="width: 196px; height: 196px" alt="AliPay.png"></td>
              <td><img src="https://www.chatqkv.com/WeChatPay.png" style="width: 196px; height: 196px" alt="WeChatPay.png"></td>
          </tr>
      </tbody>
  </table>


pkgId: 02d696c673b53714cd05906cbcb2c7af20e910a6f35cf3ff9b06d9034ea2235f
name: python-chatcli-gpt
arch: src
version: 0.9.0
epoch: 0
release: 1
url: https://github.com/cthulahoops/chatcli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatcli-gpt-0.9.0-1.src.rpm
checksum_type: sha256
summary:
  A command line interface for interacting with GPT-3. It's orientated around an append only chat log so you get a complete history of your conversations.

description:
  ChatCLI is a command-line tool that uses the OpenAI GPT-3.5/GPT-4 API to
  provide a chat bot interface that can answer your questions. It provides a
  simple and intuitive way to interact with GPT by asking questions and getting
  relevant answers.

  This command is in early development and the interface and log file format are
  unstable and changing rapidly. I'd love to get feedback on what would make this
  tool more useful.

  WARNING: This version supports EVALUATE blocks that allow GPT to evaluate code.
  This should only work if the pyeval plugin is enabled, either using "--plugin pyeval"
  or "--personality pyeval". There is no sandboxing, so GPT can run any code it
  likes if you enable this!



  The following steps will guide you through the installation process:

  1. Install with pip:

  ```
  pip install chatcli-gpt
  ```



  2. Initialise the log:

  ```
  chatcli init
  ```

  3. Set your OpenAI API key in the environment variable `OPENAI_API_KEY`.

  4. Run chatcli

  ```
  chatcli
  ```

  5. See all the commands available:
  ```
  chatcli --help
  ```





  To ask a question, just run chatcli:

  ```
  chatcli
  ```

  This will start a conversation with the chat bot, which will prompt you for a
  question. You can also include a text file as context for your question by
  using the `-f` or `--file` option:

  ```
  chatcli --file myfile.txt
  ```

  You can continue a previous conversation with the `--continue` option:

  ```
  chatcli --continue
  ```

  You can select the model you wish to use with the `--model` option, and retry
  the previous interaction with `--retry`. So to retry the previous question with GPT-4
  just do:

  ```
  chatcli --retry --model gpt-4
  ```

  You can list available models with

  ```
  $ chatcli models
  gpt-4-1106-preview
  gpt-3.5-turbo-1106
  gpt-4
  gpt-3.5-turbo
  ```

  By default the core openai models are available. You can also enable models from
  [OpenRouter](https://openrouter.ai/) with:

  ```
  export OPENROUTER_API_KEY=<your api key>
  chatcli models fetch openrouter
  ```

  You select a model using any substring of the model id. For example, you can select the
  `openrouter/anthropic/claude-2` model using:

  ```
  chatcli --model claude-2
  ```

  The first matching model is selected. This does mean it is currently impossible to start a
  conversation with the older gpt models as `gpt-4` is a substriing of `gpt-4-1106-preview`.
  The newer model is cheaper, and more powerful, so this behaviour seems reasonable.



  A conversation consists of a list messages, and some flags. Conversations typically start with
  system message, and then alternate between user and assistant messages but you can create
  conversations with any sequence of messages you like.

  You can create a new conversation and add messages to it with the `add` command:

  ```
  echo "You are a mouse and only squeak." | chatcli add
  echo "Hello!" | chatcli add --role user --continue
  echo "Squeak!" | chatcli add --role assistant --continue
  echo "How are you?" | chatcli add --role user --continue
  ```

  You can use the `answer` command to get GPT to add a message to the conversation:

  ```
  $ chatcli answer
  Squeak squeak!
  ```

  You can show the contents of a conversation the `show` command. By default it will show the most
  recent message only. Use `--long` to view the full conversation.

  ```
  $ chatcli show --long
  You are a mouse and only squeak.
  >> Hello!
  Squeak!
  >> How are you?
  Squeak squeak!
  ```



  ChatCLI keeps an append only log file with a snapshot of every conversation.
  When you create or modify a conversation a new entry is added to the log.

  Create a log file in the current directory with:

  ```
  chatcli init
  ```

  Chatcli will search for a log file in the current directory, or in any parent
  directory. You can create a single log file in your home directory and store
  your full conversation history there, or create per project log files in
  project directories.

  By default logs are saved in ".chatcli.log". You can override by setting
  environment variable `CHATCLI_LOGFILE`.

  View the log using the log command.

  ```
  chatcli log --limit 10
  ```

  You can select messages from the log using their `offset`. Most commands accept
  an offset. For example, to continue from the third most recent entry in the log
  you can use

  ```
  chatcli 3
  ```

  Similiarly, you can search for a keyword using the `--search` option. For example,
  view the most recent conversation mentioning python with

  ```
  chatcli show --search python
  ```




  A personality is just a conversation that is intended as the starting point of
  future conversations. You can see the default personality with:

  ```
  chatcli show -p default
  ```

  and list all available personalities with:

  ```
  chatcli personalities
  ```

  You can start a conversation from with any personality with:

  ```
  chatcli --personality checker
  ```

  You can create a new personality using the `add` command with the `--personality` or `-p` flag.

  ```
  $ chatcli add --personality checker
  (Finish input with <Alt-Enter> or <Esc><Enter>)
  >> You are spelling and grammar checker. Respond to every message with a list of
  spelling and grammatical errors. (If any.)
  ..
  ```

  You can also create more complex personalities by calling `add` repeatedly to build up longer
  conversation including examples of how the assistant should respond. For example, we can teach
  the image personality to generate images like this:

  ````
  chatcli add --plugin image --model gpt-4 <<- END
          You have the ability to create images from prompts using DALL-E.

          To do this provide an image block with the filename to save the
          image to and a prompt.
  END

  chatcli add -c --role user <<- 'END'
          Generate a nice landscape.
  END

  chatcli add -c --role assistant <<- 'END'
          IMAGE("landscape.png")
          ```
          A painting of the sun setting over mountains.
          ```
  END

  chatcli add -c --role user <<- 'END'
          RESULT:
          ```
          Image saved to landscape.png
          ```
  END

  chatcli add -p image -c --role assistant <<- 'END'
          Your image is in landscape.png!
  END
  ````




  A plugin allows the answers from GPT to be fed to another program (eg: python,
  a search engine, etc.), and the result fed back to GPT.

  For example, we can use the `pyeval` to work out how many days are left in the year:

  ````
  $ chatcli --personality pyeval
  (Finish input with <Alt-Enter> or <Esc><Enter>)
  >> How many days are left in the year?
  ..
  EVALUATE:
  ```
  from datetime import date, timedelta

  today = date.today()
  end_of_year = date(today.year, 12, 31)
  days_left = (end_of_year - today).days
  days_left
  ```

  RESULT:
  ```
  227
  ```
  There are 227 days left in the year.
  ````

  A plugin usually consists of the plugin itself and a personality that prompts
  gpt to explain how to interact with the plugin. Plugins usually require `gpt-4`
  to work well.

  As a user, you won't normally interact with the plugin directly, you can just
  specify a personality with a plugin enabled.

  Show the prompt for the pyeval plugin with:

  ```
  chatcli show --personality pyeval
  ```

  You could create this personality yourself by this and providing a prompt that
  explains the use of the plugin.

  ```
  chatcli add --plugin pyeval --model gpt-4
  ```




  Conversations can be tagged so you can name them and refer back to them later. You
  can add a tag to a conversation with:

  ```
  chatcli tag mytag
  ```

  You can then continue the conversation with:

  ```
  chatcli --tag mytag --continue
  ```

  Whenever you extend a tagged conversation the most recently added tag is added to the
  new conversation snapshot. In this way you can use tags like branches in git. (View the
  active tag with `chatcli show-tag`)

  Remove a tag the `untag` command:

  ```
  chatcli untag mytag
  ```

  View all tags with the `tags` command:

  ```
  chatcli tags
  ```

  You'll see that personalities are listed with tags. A personality is just a tag that starts with
  a `^`. When you add a new message to a personality, the personality tag is not copied forward.



  To display the number of tokens used and the token cost, use the `usage` command:

  ```
  chatcli usage
  ```

  Or, just view today's usage with:

  ```
  chatcli usage --today
  ```





  ```
  chatcli --quick --file chatcli_gpt/cli.py --personality code
  >> Generate a README.md for this project.
  ```



  1. Make some changes to your code and stage them for commit:

  ```
  git add -p
  ```

  2. Use `git diff` to see the changes you've made and pipe them to chatcli
     script to generate a commit message:

  ```
  git diff --cached | chatcli -p commit
  ```

  3. Make a commit with the generated message:

  ```
  git commit --edit -m "$(chatcli show)"
  ```

  This will use the `show` command to display the last message generated by GPT,
  which is then used as the commit message.

  That's it! You've successfully used ChatGPT to generate a commit message based
  on the changes you've made to your code.



  If you wish to contribute to this project, please fork the repository and submit a pull request.


pkgId: 311528369a02f9ed4abecaf7ca1c26ddf1c9b262e6ffc409843c1c174077799d
name: python-chatfaq_sdk
arch: src
version: 0.1.32
epoch: 0
release: 1
summary: ChatFAQ SDK
url: https://pypi.org/project/chatfaq_sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatfaq_sdk-0.1.32-1.src.rpm
checksum_type: sha256
description:
  For those chatbots with complex Finite State Machine (FSM) behaviours, you will probably want to run them on a separate process, that is what for the SDK is made for. Its primary function is to execute the FSM's computations (transition's conditions and states) by running Remote Procedure Call (RPC) server that listen to the back-end requests.




  Make sure the following list of packages are installed on your system:

  - Python 3.10
  - python3.10-dev
  - python3.10-distutils
  - poetry





      poetry add chatfaq-sdk





  Install project dependencies:

      poetry install



  First of all, create a `.env` file with the needed variables set. You can see an example of those on [.env_example](.env-template) file. Next you can see the explanation of each variable:

  `CHATFAQ_RETRIEVAL_HTTP`: The address for the HTTP of the back-end server.

  `CHATFAQ_BACKEND_WS`: The address for the WS of the back-end server.

  `CHATFAQ_TOKEN`: The token to authenticate with the back-end server. You can retrieve the auth token from the backend server:

  `curl -X POST -u username:password http://localhost:8000/back/api/login/`


  Run the example:

      make run_example

  This will run the example FSM that is located in [./examples/model_example/__init__.py](./examples/model_example/__init__.py) file. You can modify this file to test your own FSMs.




  Alternatively you can simply run the server using docker.



      docker build -t chatfaq-sdk .



      docker run chatfaq-sdk






  This is just a dummy example that displays the basic usage of the library.

  We are going to build the next FSM:

  ![fsm](../doc/source/_static/images/fsm_diagram.png)

  Import basic modules to build your first FMS:

  ```python
  import os
  import random
  from chatfaq_sdk import ChatFAQSDK
  from chatfaq_sdk.fsm import FSMDefinition, State, Transition
  from chatfaq_sdk.conditions import Condition
  from chatfaq_sdk.layers import Message
  ```

  Declare the 3 possible states of our FSM:

  ```python
  def send_greeting(ctx: dict):
      yield Message("Hello!")
      yield Message("How are you?", allow_feedback=False)

  greeting_state = State(name="Greeting", events=[send_greeting], initial=True)


  def send_answer(ctx: dict):
      last_payload = ctx["conv_mml"][-1]["stack"][0]["payload"]["content"]
      yield Message(
          f'My answer to your message: "{last_payload}" is: {random.randint(0, 999)}'
      )
      yield Message("Tell me more")

  answering_state = State(
      name="Answering",
      events=[send_answer],
  )


  def send_goodbye(ctx: dict):
      yield Message("Byeeeeeeee!", allow_feedback=False)

  goodbye_state = State(
      name="Goodbye",
      events=[send_goodbye],
  )

  ```

  Declare the only computable condition for the transitions of our FSM:

  ```python
  def is_saying_goodbye(ctx: dict):
      if ctx["conv_mml"][-1]["stack"][0]["payload"]["content"] == "goodbye":
          return Condition(1)
      return Condition(0)
  ```

  Now lets glue everything together:

  Declare our transitions

  ```python
  any_to_goodbye = Transition(dest=goodbye_state, conditions=[is_saying_goodbye])

  greeting_to_answer = Transition(
      source=greeting_state,
      dest=answering_state,
      unless=[is_saying_goodbye],
  )
  answer_to_answer = Transition(
      source=answering_state, dest=answering_state, unless=[is_saying_goodbye]
  )
  ```

  Build the final instance of our FSM:

  ```python
  fsm_definition = FSMDefinition(
      states=[greeting_state, answering_state, goodbye_state],
      transitions=[greeting_to_answer, any_to_goodbye, answer_to_answer],
  )
  ```

  Finally, run the RPC server loop with the previously built FSM:

  ```python
  import os

  sdk = ChatFAQSDK(
      chatfaq_retrieval_http="http://localhost:8000",
      chatfaq_ws="ws://localhost:8000",
      token=os.getenv("CHATFAQ_TOKEN"),
      fsm_name="my_first_fsm",
      fsm_definition=fsm_definition,
  )
  sdk.connect()
  ```


pkgId: b64c13d9d2c7a1ef388626accf6a299eedd476ae9a1d9993fb1f41151d89638f
name: python-chatgpt-bot
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A library that takes the pain out of creating ChatGPT bots.
url: https://github.com/skorokithakis/ChatGPT-Bot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatgpt-bot-0.2.1-1.src.rpm
checksum_type: sha256
description:
  This is a small library that tries to make it easier to create a ChatGPT bot. It has
  a simple interface that keeps conversational context in a SQLite database:
  ```python
  from chatgpt_bot import Conversation
  >>> conversation = Conversation("some random ID", api_key="YOUR_OPENAI_API_KEY")
  >>> conversation.ask("Hi, how are you today?")
  "As an AI language model, I don't have feelings, but I'm always ready to assist you
  with any questions or tasks you have. How can I help you today?"
  >>> conversation.set_metadata({"anything": "here"})
  >>> conversation.get_metadata()
  {"anything": "here"}
  ```


pkgId: 1397d788230a60e5433971bd64f1ed9dac7c17d9bff707c496cedfaf3594f558
name: python-chatgpt-prompt-wrapper
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: CLI tool to wrap ChatGPT Python API.
url: https://github.com/rcmdnk/chatgpt-prompt-wrapper
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatgpt-prompt-wrapper-0.1.3-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/rcmdnk/chatgpt-prompt-wrapper/actions/workflows/test.yml/badge.svg)](https://github.com/rcmdnk/chatgpt-prompt-wrapper/actions/workflows/test.yml)
  [![test coverage](https://img.shields.io/badge/coverage-check%20here-blue.svg)](https://github.com/rcmdnk/chatgpt-prompt-wrapper/tree/coverage)

  Python CLI implementation for [ChatGPT](https://openai.com/blog/chatgpt).



  - Python >= 3.10



  By Homebrew:

  ```
  $ brew install rcmdnk/rcmdnkpac/chatgpt-prompt-wrapper
  ```

  By pip:

  ```
  $ pip3 install chatgpt-prompt-wrapper
  ```



  To get an OpenAI API key, go to [Account API Keys - OpenAI API](https://platform.openai.com/account/api-keys).

  Set it as the environment variable `OPENAI_API_KEY`.

  To load the variable when you start the terminal, write it in **.bashrc** or **.zshrc**.

  ```
  export OPENAI_API_KEY="sk-..."
  ```

  Alternatively, pass the key using the '-k' or '--key' argument in the command.





  ```
  $ cg help
  usage: cg [-h] [-k KEY] [-c CONF] [-m MODEL] [-t MAX_TOKENS] [-T MIN_MAX_TOKENS] [-l TOKENS_LIMIT] [--show] [--hide] [--multiline]
            [--no_multiline] [--vi] [--emacs] [--show_cost]
            subcommand [message ...]

  positional arguments:
    subcommand            Subcommand to run. Use 'commands' subcommand to list up available subcommands.
    message               Message to send to ChatGPT

  optional arguments:
    -h, --help            show this help message and exit
    -k KEY, --key KEY     OpenAI API key.
    -c CONF, --conf CONF  Path to the configuration toml file.
    -m MODEL, --model MODEL
                          ChatGPT Model to use.
    -t MAX_TOKENS, --max_tokens MAX_TOKENS
                          The maximum number of tokens to generate in the chat completion. Set 0 to use the max values for the model
                          minus prompt tokens.
    -T MIN_MAX_TOKENS, --min_max_tokens MIN_MAX_TOKENS
                          The minimum of max_tokens for the completion when max_tokens = 0.
    -l TOKENS_LIMIT, --tokens_limit TOKENS_LIMIT
                          The limit of the total tokens of the prompt and the completion. Set 0 to use the max values for the model.
    --show                Show prompt for ask command.
    --hide                Hide prompt for ask command.
    --multiline           Use multiline input for chat command.
    --no_multiline        Use single line input for chat command.
    --vi                  Use vi mode at chat.
    --emacs               Use emacs mode at chat.
    --show_cost           Show cost used.
  ```

  ```

  $ cg commands
  Available subcommands:
    Reserved commands:
      ask       : Ask w/o predefined prompt.
      chat      : Start chat w/o predefined prompt.
      discuss   : Start a discussion between GPTs. Give a them as a message.
      init      : Initialize config file with an example command.
      cost      : Show estimated cost used until now.
      commands  : List up subcommands (show this).
      version   : Show version.
      help      : Show help.
    User commands:
      test      : Example command to test the OpenAI API.
      ...
  ```



  `ask` and `chat` are reserved commands for running simple interaction without a predefined prompt.

  - `ask`

  `cg ask <message>` returns the answer from ChatGPT for `message`.

  - `chat`

  `cg chat` starts a chat.

  :memo: In `chat` mode, all messages in the past, including answers from
  ChatGPT, will be sent each time you send a new message.

  The oldest message will be dropped when the total tokens (including the reserved tokens for the completion defined by `max_tokens` or `min_max_tokens`) exceeds the tokens limit (`tokens_limit` or the number of max tokens (-1) for the used model).

  It means you will send almost the max length after a long conversation.
  Please keep the cost in mind. You may want to set `tokens_limit`.



  `discuss` is another reserved command which start a discussion between two ChatGPTs.

  Two GPTs are ask to perform as:

  - Please engage in the discussion as a supporter.
  - Please engage in the discussion as a opponent.

  You input message will be a message and they start a discussion.

  Please push `Enter` to proceed a duscussion and `Ctrl-C` to quit a discussion.



  You can define your command in the configuration files.

  A command can be in either `ask` mode, `chat` mode or `discuss` mode.

  - `ask` mode: Send a predefined prompt and a message from the command line and receive one answer.
  - `chat` mode: Start a chat with a predefined prompt if defined:
    - `chat` mode can be either `multiline` or single (`no_multiline`), and `vim` or `emacs`.
  - `discuss` mode: Start a discussion between two different ChatGPTs.



  The default path to the configuration file is **$XDG_CONFIG_HOME/cg/config.toml**.

  If **$XDG_CONFIG_HOME** is not defined, use **~/.config/cg/config.toml**.

  If it does not exist and **~/.cg/config.toml** exists,
  the existing file is used.

  You can change the path by `-c <file>` (`--conf <file>`) option.



  The configuration file is written in the [TOML format](https://toml.io/en/).

  You can define a command as the top table name.

  `global` is the special table to define global options,
  which are enabled for all commands if the command does not have the corresponding options.

  The options for each table can be:

  - `description`: Description of the command.
  - `mode`: Set `ask`, `chat` or `discuss`. (default is `ask` mode.)
  - `show_cost`: Set `true` to show the cost at the end of the command.
  - `model`: The model to use (default: "gpt-3.5-turbo").
  - `max_tokens`: The maximum number of tokens to generate in the chat completion. Set 0 to use the maximum values for the model. (default: 0)
  - `min_max_tokens`: The minimum of `max_tokens` for the completion when `max_tokens = 0`. (default: 200)
  - `tokens_limit`: The limit of the total tokens of the prompt and the completion. Set 0 to use the maximum values for the model. (default: 0)
  - `temperature`: Sampling temperature (0 ~ 2). (default: 1)
  - `top_p`: Probability (0 ~ 1) that the model will consider the top_p tokens. Do not set both temperature and top_p at the same time. (default: 1)
  - `presence_penalty`: The penalty for the model to return the same token (-2 ~ 2). (default: 0)
  - `frequency_penalty`: The penalty for the model to return the same token multiple times (-2 ~ 2). (default: 0)
  - Table of `alias`: Dictionary of role aliases. The default alias is: '`user' = 'User'`, `'system' = 'System'`, `'assistant' = 'Assistant'`.
  - `model_max_tokens`: Additional or updated model's max_token definitions.
  - `price`: Additional or updated model's price definitions.
  - List of `messages`: Dictionary of message, which must have `role` and `content` (message text).
    - For `ask`, `chat` modes, `role` must be one of `system`, `user` and `assistant`
    - For `discuss` mode, three roles, `theme`, `gpt1` and `gpt2` are needed.

  The options for ask mode:

  - `show`: Set `true` to show prompt for non chat command.
  - `hide`: Set `true` to hide prompt for non chat command (default).

  The options for chat mode:

  - `multiline`: Set `true` to hide prompt for non chat command.
  - `no_multiline`: Set `true` to hide prompt for non chat command (default).
  - `vi`: Set `true` to use vi mode.
  - `emacs`: Set `true` to use emacs mode (default).

  You can make a example configuration file by `cg init`.

  Here is a example configuration:

  ```toml
  [global]


  model = "gpt-4o-2024-08-06"









  [global.model_context_window]

  "gpt-4o-2024-08-06" = 128000

  [global.model_max_tokens]

  "gpt-4o-2024-08-06" = 16384

  [global.prices]

  "gpt-4o-2024-08-06" = [0.0025, 0.010]

  [test]



  description = "Example command to test the OpenAI API."
  show = true

  [[test.messages]]
  role = "system"
  content = "You are a helpful assistant."
  [[test.messages]]
  role = "user"
  content = "Who won the world series in 2020?"
  [[test.messages]]
  role = "assistant"
  "content" = "The Los Angeles Dodgers won the World Series in 2020."
  [[test.messages]]
  role = "user"
  content = "Where was it played?"

  [sh]
  description = "Ask a shell scripting question."
  [[sh.messages]]
  role = "user"
  content = "You are an expert of the shell scripting. Answer the following questions."

  [py]
  description = "Ask a python programming question."
  [[py.messages]]
  role = "user"
  content = "You are an expert python programmer. Answer the following questions."

  [enjoy_chat]
  description = "Chat example with a predefined prompt."
  mode = 'chat'
  [[chat.messages]]
  role = "user"
  content = "Let's enjoy a chat."


  [dd]
  mode = 'discuss'

  [dd.names]
  gpt1 = "pros"
  gpt2 = "cons"

  [[dd.messages]]
  role = "theme"
  content = "Discuss whether or not to actively adopt ChatGPT in the education field. Please provide one-sentence responses."
  [[dd.messages]]
  role = "gpt1"
  content = "Please speak from the standpoint that you should actively adopt ChatGPT in the field of education."
  [[dd.messages]]
  role = "gpt2"
  content = "Please speak from the standpoint that you should not actively adopt ChatGPT in the field of education."
  ```

  These messages will be sent as an prompt before your input message.

  You can give full questions and use `cg` w/o input messages like a first example `test` command.

  Command examples:

  - test

  ![test command](https://raw.githubusercontent.com/rcmdnk/chatgpt-prompt-wrapper/main/fig/cg_test.png)

  - sh

  ![sh command](https://raw.githubusercontent.com/rcmdnk/chatgpt-prompt-wrapper/main/fig/cg_sh.png)

  - py

  ![py command](https://raw.githubusercontent.com/rcmdnk/chatgpt-prompt-wrapper/main/fig/cg_py.png)

  - enjoy_chat

  ![chat command](https://raw.githubusercontent.com/rcmdnk/chatgpt-prompt-wrapper/main/fig/cg_chat.gif)





  See [git-gpt-commit](https://github.com/rcmdnk/git-gpt-commit).


pkgId: d59832a99aed7280ac60824d047d05241ec778355b415842bf2ff4455ef0352d
name: python-chatgpt-tool-hub
arch: src
version: 0.5.0
epoch: 0
release: 1
url: https://github.com/goldfishh/chatgpt-tool-hub
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatgpt-tool-hub-0.5.0-1.src.rpm
checksum_type: sha256
summary:
  An open-source chatgpt tool ecosystem where you can combine tools with chatgpt and use natural language to do anything.

description:
  简体中文 | [English](./docs/README_en.md)
  > 大语言模型涌现能力让人惊艳，ChatGPT出现给NLP技术带来革命，除此之外还让我意识到一种新的人机交互的可能性
  <div>
      <h2 style="display:inline; margin:0; padding:0;">🌱 5.4 LLM-OS demo在线演示</h2>
      <a style="display:inline-block; align:center" src="https://colab.research.google.com/assets/colab-badge.svg" href="https://colab.research.google.com/drive/11nYPGFCYiaZ73H8nTHSN8ifbo0u3W_8p">
          <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="demo in Colab"/>
      </a>
  </div>
  <br/>
  <div align="center">
      <a style="text-decoration:none" href="https://www.bilibili.com/video/BV1eL411h7Nk/" target="_blank">
          <img src="https://i.328888.xyz/2023/04/29/iJQNi3.jpeg" width = "659" height = "410" alt="LLM-OS" align=center />
      </a>
  </div>
  <br/>


pkgId: 6b469faf1affa2445cae2f0bfe01d45789509c6c569b8505cd4a92a34fc20f05
name: python-chatnoir-api
arch: src
version: 3.1.3
epoch: 0
release: 1
summary: Simple, type-safe access to the ChatNoir search API.
url: https://github.com/chatnoir-eu/chatnoir-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatnoir-api-3.1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/chatnoir-api?style=flat-square)](https://pypi.org/project/chatnoir-api/)
  [![CI](https://img.shields.io/github/actions/workflow/status/chatnoir-eu/chatnoir-api/ci.yml?branch=main&style=flat-square)](https://github.com/chatnoir-eu/chatnoir-api/actions/workflows/ci.yml)
  [![Code coverage](https://img.shields.io/codecov/c/github/chatnoir-eu/chatnoir-api?style=flat-square)](https://codecov.io/github/chatnoir-eu/chatnoir-api/)
  [![Python](https://img.shields.io/pypi/pyversions/chatnoir-api?style=flat-square)](https://pypi.org/project/chatnoir-api/)
  [![Issues](https://img.shields.io/github/issues/chatnoir-eu/chatnoir-api?style=flat-square)](https://github.com/chatnoir-eu/chatnoir-api/issues)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/chatnoir-eu/chatnoir-api?style=flat-square)](https://github.com/chatnoir-eu/chatnoir-api/commits)
  [![Downloads](https://img.shields.io/pypi/dm/chatnoir-api?style=flat-square)](https://pypi.org/project/chatnoir-api/)
  [![License](https://img.shields.io/github/license/chatnoir-eu/chatnoir-api?style=flat-square)](LICENSE)



  Simple, type-safe access to the [ChatNoir](https://chatnoir.web.webis.de/) [search API](https://chatnoir.web.webis.de/api/).

  Working with PyTerrier? Check out the [`chatnoir-pyterrier`](https://pypi.org/project/chatnoir-pyterrier/) package.



  Install the package from PyPI:

  ```shell
  pip install chatnoir-api
  ```



  The ChatNoir API offers two main features: [search](#search) with BM25F and [retrieving document contents](#retrieve-document-contents).



  You can use our Python client to search for documents.
  The `results` object is an iterable wrapper of the search results which handles pagination for you.
  List-style indexing is supported to access individual results or sub-lists of results:

  ```python
  from chatnoir_api.v1 import search

  results = search("python library")

  top10_results = results[:10]
  print(top10_results)

  result_1234 = results[1234]
  print(result_1234)
  ```



  To limit your search requests to a single index (e.g., ClueWeb22 category B), set the `index` parameter like this:

  ```python
  from chatnoir_api import Index
  from chatnoir_api.v1 import search

  api_key: str = "<API_KEY>"
  results = search("python library", index="clueweb22/b")
  ```



  To search for phrases, use the `search_phrases` method in the same way as normal `search`:

  ```python
  from chatnoir_api.v1 import search_phrases

  results = search_phrases("python library")
  ```



  The public, shared, default API key comes with a limited request budget.
  To use the ChatNoir API more extensively, please request a dedicated [API key](https://chatnoir.web.webis.de/apikey/).

  Then, use the `api_key` parameter to add it to your requests like this:

  ```python
  results = search("python library", api_key="<YOUR_API_KEY>")
  ```



  To generate text with the ChatNoir Chat API you need to request an API key from the [admins](mailto:maik.froebe@uni-jena.de).
  With your API key, you can chat with the cat, like this:

  ```python
  from chatnoir_api.chat import ChatNoirChatClient

  chat_client = ChatNoirChatClient(api_key="<API_KEY>")
  response = chat_client.chat("how are you?")
  ```



  Often the title and ID of a document is not enough to effectively re-rank a list of search results.
  To retrieve the full content or plain text for a given document you can use the `html_contents` helper function.
  The `html_contents` function expects a ChatNoir-internal UUID, shorthand UUID, or a TREC ID and the index from which to retrieve the document.



  You can retrieve a document by its TREC ID like this:

  ```python
  from chatnoir_api import cache_contents, Index

  contents = cache_contents(
      "clueweb09-en0051-90-00849",
      index="clueweb09",
  )
  print(contents)

  plain_contents = cache_contents(
      "clueweb09-en0051-90-00849",
      index="clueweb09",
      plain=True,
  )
  print(plain_contents)
  ```



  For newer ChatNoir versions, you can also retrieve a document by its ChatNoir-internal _short_ UUID like this:

  ```python
  from chatnoir_api import cache_contents, Index, ShortUUID

  contents = cache_contents(
      ShortUUID("MzOlTIayX9ub7c13GLPr_g"),
      index="clueweb22/b",
  )
  print(contents)

  plain_contents = cache_contents(
      ShortUUID("MzOlTIayX9ub7c13GLPr_g"),
      index="clueweb22/b",
      plain=True,
  )
  print(plain_contents)
  ```

  <!-- ## Citation

  If you use this package, please cite the [paper](https://webis.de/publications.html#bevendorff_2018)
  from the [ChatNoir](https://github.com/chatnoir-eu) authors.
  You can use the following BibTeX information for citation:

  ```bibtex
  @InProceedings{bevendorff:2018,
    address =               {Berlin Heidelberg New York},
    author =                {Janek Bevendorff and Benno Stein and Matthias Hagen and Martin Potthast},
    booktitle =             {Advances in Information Retrieval. 40th European Conference on IR Research (ECIR 2018)},
    editor =                {Leif Azzopardi and Allan Hanbury and Gabriella Pasi and Benjamin Piwowarski},
    month =                 mar,
    publisher =             {Springer},
    series =                {Lecture Notes in Computer Science},
    site =                  {Grenoble, France},
    title =                 {{Elastic ChatNoir: Search Engine for the ClueWeb and the Common Crawl}},
    year =                  2018
  }
  ``` -->



  To build this package and contribute to its development you need to install the `build`, and `setuptools` and `wheel` packages:

  ```shell
  pip install build setuptools wheel
  ```

  (On most systems, these packages are already pre-installed.)



  Install package and test dependencies:

  ```shell
  pip install -e .[tests]
  ```



  Configure the API keys for testing:

  ```shell
  export CHATNOIR_API_KEY="<API_KEY>"
  export CHATNOIR_API_KEY_CHAT="<API_KEY>"
  ```

  Verify your changes against the test suite to verify.

  ```shell
  ruff check .                   # Code format and LINT
  mypy .                         # Static typing
  bandit -c pyproject.toml -r .  # Security
  pytest .                       # Unit tests
  ```

  Please also add tests for your newly developed code.



  Wheels for this package can be built with:

  ```shell
  python -m build
  ```



  If you hit any problems using this package, please file an [issue](https://github.com/chatnoir-eu/chatnoir-api/issues/new).
  We're happy to help!



  This repository is released under the [MIT license](LICENSE).


pkgId: d6f60fbe20b3f05425a17d87acda827113e84b19fd681226ef65db88ccef0e62
name: python-chatpdb
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: A chatgpt enabled python debugger
url: https://github.com/never-over/chatpdb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatpdb-0.1.14-1.src.rpm
checksum_type: sha256
description:
        3
  ipdb> y
  The exception occurred because the function `echo_platform` tries to concatenate the string "You are running on:" with the `platform` variable, which is `None`. [...]
  ```
  Type `y "prompt"` to ask a question.
  ```python3
  > /Programming/test-chatpdb/lib.py(2)echo_platform()


pkgId: 81930b5540a53f0413e75d5c40c535b6edb1fdd691a5510fe3fb143742a3e814
name: python-chatrouter
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Typed router for chatbot
url: https://github.com/cirebon-dev/chatrouter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatrouter-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![status workflow test](https://github.com/cirebon-dev/chatrouter/actions/workflows/python-app.yml/badge.svg)](https://github.com/cirebon-dev/chatrouter/actions)
  [![status workflow build](https://github.com/cirebon-dev/chatrouter/actions/workflows/release_to_pypi.yml/badge.svg)](https://github.com/cirebon-dev/chatrouter/actions)

  [![Downloads](https://static.pepy.tech/badge/chatrouter)](https://pepy.tech/project/chatrouter)
  [![Downloads](https://static.pepy.tech/badge/chatrouter/month)](https://pepy.tech/project/chatrouter)
  [![Downloads](https://static.pepy.tech/badge/chatrouter/week)](https://pepy.tech/project/chatrouter)

  Chatrouter is an enhanced router for chatbots and easily integrates with any bot library.



  1. turned complexity into simplicity.

  from:
  ```python
  if user_session == "A":
      ...
  elif user_session == "B":
      ...
  elif user_session == "C":
      ...
  else:
      ...
  ```
  to:
  ```python
  chatbot = chatrouter.group(user_session)
  r = chatrouter.run(chatbot, msg)
  ```
  2. Readable route.

  ```python
  @chatbot.add_command("call me {my_name}")

  chatbot.add_command("call me {my_name} and {my_friend}")

  ```

  3. case sensitive and insensitive.

  default case is `insensitive` but you can add `strict=True` to a route/command to make it case  sensitive.

  4. public and private command.

  command start with "/" and have description is public command, for example:
  ```python
  @chatbot.add_command("/test", description="test command", strict=True)
  ```
  5. invoke callback anywhere.

  ```python
  func = chatrouter.util.get_func("group_name", "command_name")
  ```

  or

  ```python
  chatrouter.invoke("group", "route", *args, **kwargs)
  ```

  6. auto generated `/start` and `/help` command.

  7. object storage `chatrouter.data_user`.

  8. support route with regex.

  9. support autoloader `chatrouter.autoloader("path")`.

  10. support Asynchronous.

  11. typed python.



  ```
  pip install chatrouter
  ```



  for usage, please see [examples](https://github.com/cirebon-dev/chatrouter/tree/main/examples) directory.


pkgId: 4950279586bc8356133292b00a564464ab8048948df908215e4723e34bdba9e8
name: python-chatsapi
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: The World's Fastest AI Agent Framework. Based on SBERT & SpaCy Transforms.
url: https://github.com/chatsapi/chatsapi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatsapi-0.1.0-1.src.rpm
checksum_type: sha256
description:
  **The World's Fastest AI Agent Framework.**
  Based on **SBERT** and **SpaCy Transforms**, ChatsAPI is designed to enable seamless natural language processing for AI-powered conversational agents. With hybrid search capabilities and an extensible architecture, ChatsAPI offers blazing-fast performance and intuitive route management.


  ![ChatsAPI-Banner.png](docs_src%2Fimages%2FChatsAPI-Banner.png)




  - **SBERT & SpaCy-Based NLP**: Combines the power of Sentence-BERT embeddings and SpaCy for intelligent semantic matching and entity extraction.
  - **Hybrid Search**: Supports HNSWlib-based nearest neighbor search and BM25 hybrid search for efficient query handling.
  - **Dynamic Routing**: Easily define conversational routes with decorators.
  - **Parameter Extraction**: Automatically extract parameters from user input with flexible type handling.
  - **LLM Integration**: Integrates with popular LLMs such as OpenAI, Gemini, and LlamaAPI for extended conversational capabilities.
  - **Conversation Management**: Supports multi-session conversation handling with unique session IDs.




  Install the package via pip:

  ```bash
  pip install chatsapi
  ```






  ```python
  from chatsapi import ChatsAPI

  chat = ChatsAPI(
      llm_type="gemini",  # Choose LLM type (e.g., gemini, openai, ollama)
      llm_model="models/gemini-pro",  # Specify model
      llm_api_key="YOUR_API_KEY"  # API key for the LLM
  )
  ```




  Define conversational routes using decorators. Routes map user inputs to specific handler functions.

  ```python
  @chat.trigger("Want to cancel a credit card.")
  @chat.extract([("card_number", "Credit card number (a 12-digit number)", str, None)])
  async def cancel_credit_card(chat_message: str, extracted: dict):
      return {"message": chat_message, "extracted": extracted}
  ```

  **Explanation:**
  - `@chat.trigger`: Registers the route with a user-friendly description.
  - `@chat.extract`: Automatically extracts parameters from user input.




  Use the `run` method to handle user inputs.

  ```python
  async def main():
      response = await chat.run("I want to cancel my credit card.")
      print(response)
  ```




  ```python
  from fastapi import FastAPI, Request, Response
  from pydantic import BaseModel
  from chatsapi import ChatsAPI

  app = FastAPI()
  chat = ChatsAPI(
      llm_type="gemini",
      llm_model="models/gemini-pro",
      llm_api_key="YOUR_API_KEY",
  )

  @chat.trigger("Need help with account settings.")
  @chat.extract([
      ("account_number", "Account number (a 9-digit number)", int, None),
      ("holder_name", "Account holder's name (a person name)", str, None)
  ])
  async def account_help(chat_message: str, extracted: dict):
      return {"message": chat_message, "extracted": extracted}

  class RequestModel(BaseModel):
      message: str

  @app.post("/chat")
  async def message(request: RequestModel):
      reply = await chat.run(request.message)
      return {"response": reply}
  ```




  ChatsAPI supports multi-session conversations using unique session IDs:

  ```python
  session_id = chat.set_session()  # Start a new session
  response = await chat.conversation("Tell me about my account", session_id)
  print(response)

  chat.end_session(session_id)  # End the session
  ```




  - OpenAI (ChatGPT)
  - Gemini
  - LlamaAPI
  - Ollama




  - **SBERT**: Used for creating sentence embeddings.
  - **HNSWlib**: Provides fast approximate nearest neighbor search.
  - **BM25**: Implements Okapi BM25 for token-based matching.
  - **SpaCy**: Handles natural language parsing and entity recognition.


  ![logical_flow.png](docs_src%2Fimages%2Flogical_flow.png)




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




  Contributions are welcome! Feel free to open issues or submit pull requests.


pkgId: 1a3e474f4e503104d2a7e7839848951722c3ece787607f4c98bd2e87a7eb0669
name: python-chatsky
arch: src
version: 0.9.0
epoch: 0
release: 1
url: https://github.com/deeppavlov/chatsky
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatsky-0.9.0-1.src.rpm
checksum_type: sha256
summary:
  Chatsky is a free and open-source software stack for creating chatbots, released under the terms of Apache License 2.0.

description:
  ![Chatsky](https://raw.githubusercontent.com/deeppavlov/chatsky/master/docs/source/_static/images/Chatsky-full-dark.svg)

  [![Documentation Status](https://github.com/deeppavlov/chatsky/workflows/build_and_publish_docs/badge.svg?branch=dev)](https://deeppavlov.github.io/chatsky)
  [![Codestyle](https://github.com/deeppavlov/chatsky/workflows/codestyle/badge.svg?branch=dev)](https://github.com/deeppavlov/chatsky/actions/workflows/codestyle.yml)
  [![Tests](https://github.com/deeppavlov/chatsky/workflows/test_coverage/badge.svg?branch=dev)](https://github.com/deeppavlov/chatsky/actions/workflows/test_coverage.yml)
  [![License Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/deeppavlov/chatsky/blob/master/LICENSE)
  ![Python 3.8, 3.9, 3.10, 3.11](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-green.svg)
  [![PyPI](https://img.shields.io/pypi/v/chatsky)](https://pypi.org/project/chatsky/)
  [![Downloads](https://static.pepy.tech/badge/chatsky)](https://pepy.tech/project/chatsky)

  Chatsky allows you to develop conversational services.
  Chatsky offers a specialized domain-specific language (DSL) for quickly writing dialogs in pure Python. The service is created by defining a special dialog graph that determines the behavior of the dialog agent. The latter is then leveraged in the Chatsky pipeline.
  You can use the framework in various services such as social networks, call centers, websites, personal assistants, etc.

  Chatsky, a versatile Python-based conversational service framework, can be deployed across a spectrum of platforms,
  ensuring flexibility for both novice and seasoned developers:

  - Cloud platforms like AWS, Azure, and GCP offer scalable environments for Chatsky,
    with options such as AWS Lambda and Azure Functions providing serverless execution.
  - For containerized deployment, Docker and Kubernetes streamline the orchestration of Chatsky applications.
  - Furthermore, the framework's adaptability extends to IoT ecosystems,
    making it suitable for integration with edge devices in scenarios like smart homes or industrial automation.

  Whether deployed on cloud platforms, containerized environments, or directly on IoT devices,
  Chatsky's accessibility and customization options make it a robust choice for developing conversational services
  in the evolving landscape of Python applications and IoT connectivity.



  * Written in pure Python, the framework is easily accessible for both beginners and experienced developers.
  * For the same reason, all the abstractions used in Chatsky can be easily customized and extended using regular language synthax.
  * Chatsky offers easy and straightforward tools for state management which is as easy as setting values of a Python dictionary.
  * The framework is being actively maintained and thoroughly tested. The team is open to suggestions and quickly reacts to bug reports.





  - Supported operating systems include Ubuntu 18.04+, Windows 10+ (partial support), and MacOS Big Sur (partial support);
  - Python version 3.8 or higher is necessary for proper functionality;
  - A minimum of 1 GB of RAM is required for optimal performance;
  - If analytics collection or database integration is intended, Docker version 20 or higher may be necessary.




  Chatsky can be installed via pip:

  ```bash
  pip install chatsky
  ```

  The above command will set the minimum dependencies to start working with Chatsky.
  The installation process allows the user to choose from different packages based on their dependencies, which are:
  ```bash
  pip install chatsky[json]  # dependencies for using JSON
  pip install chatsky[pickle] # dependencies for using Pickle
  pip install chatsky[redis]  # dependencies for using Redis
  pip install chatsky[mongodb]  # dependencies for using MongoDB
  pip install chatsky[mysql]  # dependencies for using MySQL
  pip install chatsky[postgresql]  # dependencies for using PostgreSQL
  pip install chatsky[sqlite]  # dependencies for using SQLite
  pip install chatsky[ydb]  # dependencies for using Yandex Database
  pip install chatsky[telegram]  # dependencies for using Telegram
  pip install chatsky[benchmark]  # dependencies for benchmarking
  ```

  For example, if you are going to use one of the database backends,
  you can specify the corresponding requirements yourself. Multiple dependencies can be installed at once, e.g.
  ```bash
  pip install chatsky[postgresql,mysql]
  ```



  The following code snippet builds a simplistic chat bot that replies with messages
  ``Hi!`` and ``OK`` depending on user input, which only takes a few lines of code.
  All the abstractions used in this example are thoroughly explained in the dedicated
  [user guide](https://deeppavlov.github.io/chatsky/user_guides/basic_conceptions.html).

  ```python
  from chatsky import (
      GLOBAL,
      TRANSITIONS,
      RESPONSE,
      Pipeline,
      conditions as cnd,
      Transition as Tr,
  )


  script = {
      GLOBAL: {
          TRANSITIONS: [
              Tr(
                  dst=("flow", "node_hi"),
                  cnd=cnd.ExactMatch("Hi"),
              ),
              Tr(
                  dst=("flow", "node_ok")
              )
          ]
      },
      "flow": {
          "node_hi": {RESPONSE: "Hi!"},
          "node_ok": {RESPONSE: "OK"},
      },
  }


  pipeline = Pipeline(script, start_label=("flow", "node_hi"))


  pipeline.run()
  ```

  When you run this code, you get similar output:
  ```
  request: hi
  response: text='OK'
  request: Hi
  response: text='Hi!'
  ```

  More advanced examples are available as a part of documentation:
  [tutorials](https://deeppavlov.github.io/chatsky/tutorials.html).



  To further explore the API of the framework, you can make use of the [detailed documentation](https://deeppavlov.github.io/chatsky/index.html).
  Broken down into several sections to highlight all the aspects of development with Chatsky,
  the documentation for the library is constantly available online.



  We are open to accepting pull requests and bug reports.
  Please refer to [CONTRIBUTING.md](https://github.com/deeppavlov/chatsky/blob/master/CONTRIBUTING.md).



  Chatsky is distributed under the terms of the [Apache License 2.0](https://github.com/deeppavlov/chatsky/blob/master/LICENSE).


pkgId: 5898187417a55903fb52c583a631db7465d6ac3dfeda2e67c10b2d1ebf308113
name: python-chatterbot-corpus
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/chatterbot-corpus/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatterbot-corpus-1.2.0-1.src.rpm
checksum_type: sha256
description:
          |Package Version| |Build Status|
          These modules are used to quickly train ChatterBot to respond to various
          inputs in different languages. Although much of ChatterBot is designed
          to be language independent, it is still useful to have these training
          sets available to prime a fresh database and make the variety of
          responses that a bot can yield much more diverse.
          For instructions on how to use these data sets, please refer to the
          `project
          documentation <http://chatterbot.readthedocs.io/en/latest/training.html#training-with-corpus-data>`__.
          All training data contained within this corpus is user contributed.
          If you are interested in contributing support for a new language please
          create a pull request. Additions are welcomed!


pkgId: d80643442dcded5182261f614947d7f9db5d97d5637f271ac39e487494566ad4
name: python-chatterpyv1
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A Python library for FAISS indexing and OpenAI query processing.
url: https://github.com/Mamlesh18/chatterPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatterpyv1-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This Python library provides functionality to create and search a FAISS index using sentence embeddings and the Azure OpenAI API.



  To install the library, use pip:


pkgId: e8eb4bfe282606528f7e6c5012a116e29402686ffc256700905ec1bf95136811
name: python-chattool
arch: src
version: 3.3.4
epoch: 0
release: 1
summary: Toolkit for Chat API
url: https://github.com/cubenlp/chattool
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chattool-3.3.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://pypi.python.org/pypi/chattool">
          <img src="https://img.shields.io/pypi/v/chattool.svg" alt="PyPI version" />
      </a>
      <a href="https://github.com/cubenlp/chattool/actions/workflows/test.yml">
          <img src="https://github.com/cubenlp/chattool/actions/workflows/test.yml/badge.svg" alt="Tests" />
      </a>
      <a href="https://chattool.cubenlp.com">
          <img src="https://img.shields.io/badge/docs-github_pages-blue.svg" alt="Documentation Status" />
      </a>
      <a href="https://codecov.io/gh/cubenlp/chattool">
          <img src="https://codecov.io/gh/cubenlp/chattool/branch/master/graph/badge.svg" alt="Coverage" />
      </a>
  </div>

  <div align="center">
      <img src="https://qiniu.wzhecnu.cn/PicBed6/picgo/chattool.jpeg" alt="ChatAPI Toolkit" width="360", style="border-radius: 20px;">

  [English](README_en.md) | [简体中文](README.md)
  </div>

  基于 OpenAI API 的 `Chat` 对象，支持多轮对话，代理，以及异步处理数据等。



  ```bash
  pip install chattool --upgrade
  ```





  通过环境变量设置密钥和代理，比如在 `~/.bashrc` 或者 `~/.zshrc` 中追加

  ```bash
  export OPENAI_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
  export OPENAI_API_BASE="https://api.example.com/v1"
  export OPENAI_API_BASE_URL="https://api.example.com" # 可选
  ```

  或者在代码中设置：

  ```py
  import chattool
  chattool.api_key = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
  chattool.api_base = "https://api.example.com/v1"
  ```

  注：环境变量 `OPENAI_API_BASE` 优先于 `OPENAI_API_BASE_URL`，二者选其一即可。



  示例1，多轮对话：

  ```python

  chat = Chat("Hello, GPT-3.5!")
  resp = chat.getresponse()


  chat.user("How are you?")
  next_resp = chat.getresponse()


  chat.user("What's your name?")
  chat.assistant("My name is GPT-3.5.")


  chat.save("chat.json", mode="w") # 默认为 "a"


  chat.print_log()
  ```

  示例2，批量处理数据（串行），并使用缓存文件 `chat.jsonl`：

  ```python

  def data2chat(msg):
      chat = Chat()
      chat.system("你是一个熟练的数字翻译家。")
      chat.user(f"请将该数字翻译为罗马数字：{msg}")
      
      chat.getresponse()
      return chat

  checkpoint = "chat.jsonl" # 缓存文件的名称
  msgs = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]

  continue_chats = process_chats(msgs, data2chat, checkpoint)
  ```

  示例3，批量处理数据（异步并行），用不同语言打印 hello，并使用两个协程：

  ```python
  from chattool import async_chat_completion, load_chats, Chat

  langs = ["python", "java", "Julia", "C++"]
  def data2chat(msg):
      chat = Chat()
      chat.user("请用语言 %s 打印 hello world" % msg)
      
      return chat

  async_chat_completion(langs, chkpoint="async_chat.jsonl", nproc=2, data2chat=data2chat)
  chats = load_chats("async_chat.jsonl")
  ```

  在 Jupyter Notebook 中运行，因其[特殊机制](https://stackoverflow.com/questions/47518874/how-do-i-run-python-asyncio-code-in-a-jupyter-notebook)，需使用 `await` 关键字和 `wait=True` 参数：

  ```python
  await async_chat_completion(langs, chkpoint="async_chat.jsonl", nproc=2, data2chat=data2chat, wait=True)
  ```



  定义函数：

  ```python
  def add(a: int, b: int) -> int:
      """
      This function adds two numbers.

      Parameters:
          a (int): The first number.
          b (int): The second number.

      Returns:
          int: The sum of the two numbers.
      """
      return a + b

  def mult(a:int, b:int) -> int:
      """This function multiplies two numbers.
      It is a useful calculator!

      Args:
          a (int): The first number.
          b (int): The second number.

      Returns:
          int: The product of the two numbers.
      """
      return a * b
  ```

  添加函数到 `Chat` 对象：

  ```py
  from chattool import Chat
  chat = Chat("find the value of (23723 * 1322312 ) + 12312")
  chat.settools([add, mult])
  ```

  自动执行工具，根据返回信息判断是否结束，`maxturns` 默认为 3：

  ```py
  chat.autoresponse(display=True, tool_type='tool_choice', maxturns=3)
  ```

  使用通用函数 `python`

  ```py
  from chattool.functioncall import python
  chat = Chat("find the value of (23723 * 1322312 ) + 12312")
  chat.settools([python])
  chat.autoresponse(display=True, tool_type='tool_choice', maxturns=3)
  ```

  注意，执行模型生成的任意代码有潜在风险。



  使用 MIT 协议开源。



  - 当前版本 `3.2.1`，简化异步处理和串行处理的接口，更新子模块名称，避免冲突
  - 版本 `2.3.0`，支持调用外部工具，异步处理数据，以及模型微调功能
  - 版本 `2.0.0` 开始，更名为 `chattool`
  - 版本 `1.0.0` 开始，支持异步处理数据
  - 版本 `0.6.0` 开始，支持 [function call](https://platform.openai.com/docs/guides/gpt/function-calling) 功能
  - 版本 `0.5.0` 开始，支持使用 `process_chats` 处理数据，借助 `msg2chat` 函数以及 `checkpoint` 文件
  - 版本 `0.4.0` 开始，工具维护转至 [CubeNLP](https://github.com/cubenlp) 组织账号
  - 版本 `0.3.0` 开始不依赖模块 `openai.py` ，而是直接使用 `requests` 发送请求
      - 支持对每个 `Chat` 使用不同 API 密钥
      - 支持使用代理链接
  - 版本 `0.2.0` 改用 `Chat` 类型作为中心交互对象


pkgId: 76672c0899e9d234ef6fdec202a0e63263695b0a8ce3403825ff2262a9da24a0
name: python-chaturbate-poller
arch: src
version: 0.13.8
epoch: 0
release: 1
summary: Poller for the Chaturbate events API.
url: https://github.com/MountainGod2/chaturbate_poller
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaturbate-poller-0.13.8-1.src.rpm
checksum_type: sha256
description:
  **Chaturbate Poller** is a Python library for interacting with the Chaturbate API. It allows you to poll events asynchronously, handle various event types, and optionally store event data in InfluxDB for further analysis or monitoring.

  [![Read the Docs](https://img.shields.io/readthedocs/chaturbate-poller?link=https%3A%2F%2Fchaturbate-poller.readthedocs.io%2Fen%2Fstable%2F)](https://chaturbate-poller.readthedocs.io/en/stable/)
  [![Codecov Coverage](https://img.shields.io/codecov/c/github/MountainGod2/chaturbate_poller/main?link=https%3A%2F%2Fapp.codecov.io%2Fgh%2FMountainGod2%2Fchaturbate_poller)](https://app.codecov.io/gh/MountainGod2/chaturbate_poller/)
  [![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/MountainGod2/chaturbate_poller?link=https%3A%2F%2Fwww.codefactor.io%2Frepository%2Fgithub%2Fmountaingod2%2Fchaturbate_poller)](https://www.codefactor.io/repository/github/mountaingod2/chaturbate_poller)
  [![Workflow Status](https://img.shields.io/github/actions/workflow/status/MountainGod2/chaturbate_poller/ci-cd-build.yml?branch=main&link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller%2Factions%2Fworkflows%2Fci-cd-build.yml)](https://github.com/MountainGod2/chaturbate_poller/actions/workflows/ci-cd-build.yml/)
  [![License](https://img.shields.io/pypi/l/chaturbate-poller?link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller)](https://github.com/MountainGod2/chaturbate_poller?tab=MIT-1-ov-file)
  [![Python Version](https://img.shields.io/pypi/pyversions/chaturbate-poller?link=https%3A%2F%2Fwww.python.org%2Fdownloads%2F)](https://www.python.org/downloads/)
  [![Version](https://img.shields.io/pypi/v/chaturbate-poller?link=https%3A%2F%2Fpypi.org%2Fproject%2Fchaturbate-poller%2F)](https://pypi.org/project/chaturbate-poller/)



  - **Event Polling**: Fetch events from the Chaturbate API using Python's asyncio.
  - **Error Handling**: Includes retry logic for basic error handling during polling.
  - **Optional Logging**: Configurable logging to keep track of polling activity.
  - **InfluxDB Support**: Optionally store events in InfluxDB if data storage is required.



  Make sure you have Python 3.11 or later installed, then install the package:

  ```bash
  pip install chaturbate-poller
  ```



  To get started, create a `.env` file in the root of your project directory. This file will store your API credentials and (if applicable) InfluxDB connection details:

  ```text
  CB_USERNAME="your_chaturbate_username"
  CB_TOKEN="your_chaturbate_token"
  INFLUXDB_URL="http://influxdb:8086"
  INFLUXDB_TOKEN="your_influxdb_token"
  INFLUXDB_ORG="chaturbate-poller"
  INFLUXDB_BUCKET="your_bucket"
  USE_DATABASE="true"  # Enable if you plan to use InfluxDB
  ```

  > [!NOTE]
  > To create an API token, click here: [https://chaturbate.com/statsapi/authtoken/](https://chaturbate.com/statsapi/authtoken/)

  > [!IMPORTANT]
  > Ensure you have the "**Events API**" permission selected before generating





  You run Chaturbate Poller directly from the command line:

  ```bash
  python -m chaturbate_poller --username <your_username> --token <your_token>
  ```

  For more options:

  ```bash
  python -m chaturbate_poller --help
  ```



  To run Chaturbate Poller in a Docker container:

  ```bash
  docker pull ghcr.io/mountaingod2/chaturbate_poller:latest
  ```

  ```bash
  docker run \
    -e CB_USERNAME="your_chaturbate_username" \
    -e CB_TOKEN="your_chaturbate_token" \
    ghcr.io/mountaingod2/chaturbate_poller:latest --verbose --testbed
  ```



  You can also import it into your programs. Here’s a simple example of how to fetch events in a loop using the library asynchronously:

  ```python
  import asyncio

  from chaturbate_poller import ChaturbateClient

  async def main():
      async with ChaturbateClient("your_username", "your_token") as client:
          url = None
          while True:
              response = await client.fetch_events(url)
              for event in response.events:

                  
                  print(event.dict())

              url = response.next_url

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



  1. Clone the repository:
     ```bash
     git clone https://github.com/MountainGod2/chaturbate_poller.git
     cd chaturbate_poller
     ```

  2. Install dependencies using [uv](https://docs.astral.sh/uv/):
     ```bash
     uv venv .venv
     uv pip install . -e
     ```



  Contributions are welcome! If you'd like to contribute:

  1. Fork the repository.
  2. Create a new feature branch.
  3. Submit a pull request.

  Please ensure that any changes pass tests and follow coding guidelines.



  This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more information.

rpm_license:
  MIT License  Copyright (c) 2024 MountainGod2  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: 6cffb0aaa56b2a2c0492c58f13b6f1abd642471907f3e40089e76d316d9d003f
name: python-chaturbate-poller
arch: src
version: 0.17.1
epoch: 0
release: 1
summary: Poller for the Chaturbate events API.
url: https://github.com/MountainGod2/chaturbate_poller
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaturbate-poller-0.17.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">



  [![Read the Docs](https://img.shields.io/readthedocs/chaturbate-poller?link=https%3A%2F%2Fchaturbate-poller.readthedocs.io%2Fen%2Fstable%2F)](https://chaturbate-poller.readthedocs.io/en/stable/)
  [![Codecov Coverage](https://img.shields.io/codecov/c/github/MountainGod2/chaturbate_poller/main?link=https%3A%2F%2Fapp.codecov.io%2Fgh%2FMountainGod2%2Fchaturbate_poller)](https://app.codecov.io/gh/MountainGod2/chaturbate_poller/)
  [![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/MountainGod2/chaturbate_poller?link=https%3A%2F%2Fwww.codefactor.io%2Frepository%2Fgithub%2Fmountaingod2%2Fchaturbate_poller)](https://www.codefactor.io/repository/github/mountaingod2/chaturbate_poller)
  [![Workflow Status](https://img.shields.io/github/actions/workflow/status/MountainGod2/chaturbate_poller/docker-build.yml?branch=main&link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller%2Factions%2Fworkflows%2Fdocker-build.yml)](https://github.com/MountainGod2/chaturbate_poller/actions/workflows/docker-build.yml/)
  [![License](https://img.shields.io/pypi/l/chaturbate-poller?link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller)](https://github.com/MountainGod2/chaturbate_poller?tab=MIT-1-ov-file)
  [![Python Version](https://img.shields.io/pypi/pyversions/chaturbate-poller?link=https%3A%2F%2Fwww.python.org%2Fdownloads%2F)](https://www.python.org/downloads/)
  [![Version](https://img.shields.io/pypi/v/chaturbate-poller?link=https%3A%2F%2Fpypi.org%2Fproject%2Fchaturbate-poller%2F)](https://pypi.org/project/chaturbate-poller/)

  </div>

  **Chaturbate Poller** is a Python library and CLI for polling events from the Chaturbate API. It provides asynchronous event handling, logging, and optional integration with InfluxDB to store event data for analysis.



  - **Event Polling**: Efficiently poll events from Chaturbate’s API.
  - **Error Handling**: Includes backoff and retry mechanisms.
  - **Logging**: Console and JSON file logging for structured insights.
  - **Optional InfluxDB Storage**: Store events in InfluxDB for analysis or monitoring.



  Ensure Python 3.11 or later is installed, then install via pip:

  ```bash
  pip install chaturbate-poller
  ```



  Create a `.env` file in your project’s root directory for API and InfluxDB credentials:

  ```text
  CB_USERNAME="your_chaturbate_username"
  CB_TOKEN="your_chaturbate_token"
  INFLUXDB_URL="http://influxdb:8086"
  INFLUXDB_TOKEN="your_influxdb_token"
  INFLUXDB_ORG="chaturbate-poller"
  INFLUXDB_BUCKET="your_bucket"
  USE_DATABASE="false"  # Set to `true` if InfluxDB is used
  ```

  > [!NOTE]
  > [Generate an API token here](https://chaturbate.com/statsapi/authtoken/) with the "Events API" permission enabled.





  Start the poller from the command line:

  ```bash
  python -m chaturbate_poller start --username <your_username> --token <your_token>
  ```

  For additional options:

  ```bash
  python -m chaturbate_poller --help
  ```



  Run Chaturbate Poller in Docker:

  ```bash
  docker pull ghcr.io/mountaingod2/chaturbate_poller:latest
  ```

  ```bash
  docker run \
    -e CB_USERNAME="your_chaturbate_username" \
    -e CB_TOKEN="your_chaturbate_token" \
    ghcr.io/mountaingod2/chaturbate_poller:latest --verbose --testbed
  ```



  To use Chaturbate Poller as a library, here's a sample script to fetch events in a loop:

  ```python
  import asyncio
  from chaturbate_poller import ChaturbateClient

  async def main():
      async with ChaturbateClient("your_username", "your_token") as client:
          url = None
          while True:
              response = await client.fetch_events(url)
              for event in response.events:
                  print(event.dict())  # Process each event

              url = response.next_url

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



  1. Clone the repository:

     ```bash
     git clone https://github.com/MountainGod2/chaturbate_poller.git
     cd chaturbate_poller
     ```

  2. Set up the environment and dependencies using [uv](https://docs.astral.sh/uv/):

     ```bash
     uv venv .venv
     uv pip install -e .
     ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a feature branch.
  3. Submit a pull request, ensuring tests and coding standards are met.



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

rpm_license:
  MIT License  Copyright (c) 2024 MountainGod2  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: dd7919f335f212046dc01b3a3d44bec2a84b729a16c60ec34b5e38254e00c71a
name: python-chaturbate-poller
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Poller for the Chaturbate events API.
url: https://github.com/MountainGod2/chaturbate_poller
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaturbate-poller-1.3.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">



  [![Read the Docs](https://img.shields.io/readthedocs/chaturbate-poller?link=https%3A%2F%2Fchaturbate-poller.readthedocs.io%2Fen%2Fstable%2F)](https://chaturbate-poller.readthedocs.io/en/stable/)
  [![Codecov Coverage](https://img.shields.io/codecov/c/github/MountainGod2/chaturbate_poller/main?link=https%3A%2F%2Fapp.codecov.io%2Fgh%2FMountainGod2%2Fchaturbate_poller)](https://app.codecov.io/gh/MountainGod2/chaturbate_poller/)
  [![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/MountainGod2/chaturbate_poller?link=https%3A%2F%2Fwww.codefactor.io%2Frepository%2Fgithub%2Fmountaingod2%2Fchaturbate_poller)](https://www.codefactor.io/repository/github/mountaingod2/chaturbate_poller)
  [![Workflow Status](https://img.shields.io/github/actions/workflow/status/MountainGod2/chaturbate_poller/docker-build.yml?branch=main&link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller%2Factions%2Fworkflows%2Fdocker-build.yml)](https://github.com/MountainGod2/chaturbate_poller/actions/workflows/docker-build.yml/)
  [![License](https://img.shields.io/pypi/l/chaturbate-poller?link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller)](https://github.com/MountainGod2/chaturbate_poller?tab=MIT-1-ov-file)
  [![Python Version](https://img.shields.io/pypi/pyversions/chaturbate-poller?link=https%3A%2F%2Fwww.python.org%2Fdownloads%2F)](https://www.python.org/downloads/)
  [![Version](https://img.shields.io/pypi/v/chaturbate-poller?link=https%3A%2F%2Fpypi.org%2Fproject%2Fchaturbate-poller%2F)](https://pypi.org/project/chaturbate-poller/)

  </div>

  **Chaturbate Poller** is a Python library and CLI for polling events from the Chaturbate API. It provides asynchronous event handling, logging, and optional integration with InfluxDB to store event data for analysis.



  - **Event Polling**: Efficiently poll events from Chaturbate’s API.
  - **Error Handling**: Includes backoff and retry mechanisms.
  - **Logging**: Console and JSON file logging for structured insights.
  - **Optional InfluxDB Storage**: Store events in InfluxDB for analysis or monitoring.



  Ensure Python 3.11 or later is installed, then install via pip:

  ```bash
  pip install chaturbate-poller
  ```



  Create a `.env` file in your project’s root directory for API and InfluxDB credentials:

  ```text
  CB_USERNAME="your_chaturbate_username"
  CB_TOKEN="your_chaturbate_token"
  INFLUXDB_URL="http://influxdb:8086"
  INFLUXDB_TOKEN="your_influxdb_token"
  INFLUXDB_ORG="chaturbate-poller"
  INFLUXDB_BUCKET="your_bucket"
  USE_DATABASE="false"  # Set to `true` if InfluxDB is used
  ```

  > [!NOTE]
  > [Generate an API token here](https://chaturbate.com/statsapi/authtoken/) with the "Events API" permission enabled.





  Run the setup program:

  ```bash
  python -m chaturbate_poller setup
  ```

  ![image](https://github.com/user-attachments/assets/6060699d-022a-4526-b323-a140ee69e9c2)

  Start the poller from the command line:

  ```bash
  python -m chaturbate_poller start --username <your_username> --token <your_token>
  ```

  ![image](https://github.com/user-attachments/assets/b80bf277-188d-4874-b52d-99f8cd6b1c3b)

  For additional options:

  ```bash
  python -m chaturbate_poller --help
  ```

  ![image](https://github.com/user-attachments/assets/e564d698-a31f-4932-835e-44786a945747)



  Run Chaturbate Poller in Docker:

  ```bash
  docker pull ghcr.io/mountaingod2/chaturbate_poller:latest
  ```

  ```bash
  docker run \
    -e CB_USERNAME="your_chaturbate_username" \
    -e CB_TOKEN="your_chaturbate_token" \
    ghcr.io/mountaingod2/chaturbate_poller:latest --verbose --testbed
  ```



  To use Chaturbate Poller as a library, here's a sample script to fetch events in a loop:

  ```python
  import asyncio
  from chaturbate_poller import ChaturbateClient

  async def main():
      async with ChaturbateClient("your_username", "your_token", testbed=False) as client:
          url = None
          while True:
              response = await client.fetch_events(url)

              for event in response.events:
                  print(event.model_dump())

              url = response.next_url

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



  1. Clone the repository:

     ```bash
     git clone https://github.com/MountainGod2/chaturbate_poller.git
     cd chaturbate_poller
     ```

  2. Set up the environment and dependencies using [uv](https://docs.astral.sh/uv/):

     ```bash
     uv venv .venv
     uv pip install -e .
     ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a feature branch.
  3. Submit a pull request, ensuring tests and coding standards are met.



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

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


pkgId: 9087ee0a238268e2b3033d980d864183d60de866905f4111264c9edbf0b5ca51
name: python-chaturbate-poller
arch: src
version: 1.4.7
epoch: 0
release: 1
summary: Poller for the Chaturbate events API.
url: https://github.com/MountainGod2/chaturbate_poller
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaturbate-poller-1.4.7-1.src.rpm
checksum_type: sha256
description:
  <div align="center">



  [![Read the Docs](https://img.shields.io/readthedocs/chaturbate-poller?link=https%3A%2F%2Fchaturbate-poller.readthedocs.io%2Fen%2Fstable%2F)](https://chaturbate-poller.readthedocs.io/en/stable/)
  [![Codecov Coverage](https://img.shields.io/codecov/c/github/MountainGod2/chaturbate_poller/main?link=https%3A%2F%2Fapp.codecov.io%2Fgh%2FMountainGod2%2Fchaturbate_poller)](https://app.codecov.io/gh/MountainGod2/chaturbate_poller/)
  [![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/MountainGod2/chaturbate_poller?link=https%3A%2F%2Fwww.codefactor.io%2Frepository%2Fgithub%2Fmountaingod2%2Fchaturbate_poller)](https://www.codefactor.io/repository/github/mountaingod2/chaturbate_poller)
  [![Workflow Status](https://img.shields.io/github/actions/workflow/status/MountainGod2/chaturbate_poller/docker-build.yml?branch=main&link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller%2Factions%2Fworkflows%2Fdocker-build.yml)](https://github.com/MountainGod2/chaturbate_poller/actions/workflows/docker-build.yml/)
  [![License](https://img.shields.io/pypi/l/chaturbate-poller?link=https%3A%2F%2Fgithub.com%2FMountainGod2%2Fchaturbate_poller)](https://github.com/MountainGod2/chaturbate_poller?tab=MIT-1-ov-file)
  [![Python Version](https://img.shields.io/pypi/pyversions/chaturbate-poller?link=https%3A%2F%2Fwww.python.org%2Fdownloads%2F)](https://www.python.org/downloads/)
  [![Version](https://img.shields.io/pypi/v/chaturbate-poller?link=https%3A%2F%2Fpypi.org%2Fproject%2Fchaturbate-poller%2F)](https://pypi.org/project/chaturbate-poller/)

  </div>

  **Chaturbate Poller** is a Python library and CLI for polling events from the Chaturbate API. It provides asynchronous event handling, logging, and optional integration with InfluxDB to store event data for analysis.



  - **Event Polling**: Efficiently poll events from Chaturbate’s API.
  - **Error Handling**: Includes backoff and retry mechanisms.
  - **Logging**: Console and JSON file logging for structured insights.
  - **Optional InfluxDB Storage**: Store events in InfluxDB for analysis or monitoring.



  Ensure Python 3.11 or later is installed, then install via pip:

  ```bash
  pip install chaturbate-poller
  ```



  Create a `.env` file in your project’s root directory for API and InfluxDB credentials:

  ```text
  CB_USERNAME="your_chaturbate_username"
  CB_TOKEN="your_chaturbate_token"
  INFLUXDB_URL="http://influxdb:8086"
  INFLUXDB_TOKEN="your_influxdb_token"
  INFLUXDB_ORG="chaturbate-poller"
  INFLUXDB_BUCKET="your_bucket"
  USE_DATABASE="false"  # Set to `true` if InfluxDB is used
  ```

  > [!NOTE]
  > [Generate an API token here](https://chaturbate.com/statsapi/authtoken/) with the "Events API" permission enabled.





  Run the setup program:

  ```bash
  python -m chaturbate_poller setup
  ```

  ![image](https://github.com/user-attachments/assets/6060699d-022a-4526-b323-a140ee69e9c2)

  Start the poller from the command line:

  ```bash
  python -m chaturbate_poller start --username <your_username> --token <your_token>
  ```

  ![image](https://github.com/user-attachments/assets/b80bf277-188d-4874-b52d-99f8cd6b1c3b)

  For additional options:

  ```bash
  python -m chaturbate_poller --help
  ```

  ![image](https://github.com/user-attachments/assets/e564d698-a31f-4932-835e-44786a945747)



  Run Chaturbate Poller in Docker:

  ```bash
  docker pull ghcr.io/mountaingod2/chaturbate_poller:latest
  ```

  ```bash
  docker run \
    -e CB_USERNAME="your_chaturbate_username" \
    -e CB_TOKEN="your_chaturbate_token" \
    ghcr.io/mountaingod2/chaturbate_poller:latest --verbose --testbed
  ```



  To use Chaturbate Poller as a library, here's a sample script to fetch events in a loop:

  ```python
  import asyncio
  from chaturbate_poller import ChaturbateClient

  async def main():
      async with ChaturbateClient("your_username", "your_token", testbed=False) as client:
          url = None
          while True:
              response = await client.fetch_events(url)

              for event in response.events:
                  print(event.model_dump())

              url = response.next_url

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



  1. Clone the repository:

     ```bash
     git clone https://github.com/MountainGod2/chaturbate_poller.git
     cd chaturbate_poller
     ```

  2. Set up the environment and dependencies using [uv](https://docs.astral.sh/uv/):

     ```bash
     uv venv
     uv sync --all-extras
     ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a feature branch.
  3. Submit a pull request, ensuring tests and coding standards are met.



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

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


pkgId: 6311e999ac3e65a5fcff8b6d10bba1756adb5c4f6248bf0e064738c6606d92c1
name: python-chatushka
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Bot that can make your chat explode!
url: https://github.com/shpaker/chatushka
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatushka-0.10.1-1.src.rpm
checksum_type: sha256
description:
  Бот для чатиков (пока только для телеграмушки)






  ```shell
  pip install chatushka
  ```



  ```shell
  python -m chatushka --token <telegrambotapitoken>
  ```



  - [x] добавить ботика в чат
  - [x] делегировать боту админские права
  - [x] написать в чатик /help

  ```shell
  python -m chatushka --token <telegrambotapitoken>
  ```


pkgId: 499e62d041f76ce04562b57f5a1dbd0d912c64dc8200c89ae089cf52752361d2
name: python-chatwithsql
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: ChatWithSQL: Secure, Schema-Validated Text-to-SQL, Eliminating Arbitrary Query Risks from LLMs
url: https://github.com/sathninduk/ChatWithSQL
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chatwithsql-0.1.0-1.src.rpm
checksum_type: sha256
description:
  **ChatWithSQL** is a Python library that bridges the gap between natural language queries and SQL databases. Designed for reliability, security, and performance, ChatWithSQL allows developers to leverage advanced Language Learning Models (LLMs) like OpenAI, Gemini, and more to retrieve database data using simple, intuitive natural language prompts.




  A major risk of Text-to-SQL systems is the potential execution of arbitrary SQL queries, which can result in **unauthorized data access, security vulnerabilities, inefficient query performance, or incorrect query results**. Common mitigations include using restricted roles, read-only databases, and sandboxed environments. However, ChatWithSQL takes this one step further.


  ChatWithSQL has implemented a **schema-based validation approach** to ensure that only SQL queries adhering to a predefined schema are generated and executed. This mechanism restricts the scope of data retrieval strictly within the defined parameters, effectively mitigating the risks of arbitrary or malicious queries. Each query is validated against the schema before execution, **guaranteeing compliance and eliminating unauthorized access**.


  This unique approach positions ChatWithSQL as a leader in secure and reliable, natural language-driven SQL data retrieval.




  - **Natural Language to SQL**: Translate human-readable prompts into actionable SQL queries.
  - **Schema-Validated Queries**: Ensures only schema-defined queries are executed, mitigating arbitrary query risks.
  - **LLM Flexibility**: Seamless integration with multiple LLMs (Gemini, OpenAI, Ollama, LlamaAPI).
  - **Secure Execution**: Parameter validation and query sanitization to prevent SQL injection and unauthorized access.
  - **Dynamic Query Parameter Handling**: Automatically extracts, validates, and maps parameters to SQL placeholders.
  - **Database-Agnostic**: Compatible with any database supported by the URI connection format.
  - **Comprehensive Logging**: Provides detailed logs for easier debugging and monitoring.




  You can install ChatWithSQL using pip:

  ```bash
  pip install chatwithsql
  ```






  ```python
  from chat_with_sql import ChatWithSQL


  database_url = "your_database_url"
  llm = "openai"  # Supported: gemini, openai, llama_api, ollama
  model_name = "gpt-3.5-turbo"
  api_key = "your_llm_api_key"
  query_schema = [
      {
          "description": "Retrieve user data by user ID",
          "name": "get_user_data",
          "sql": "SELECT * FROM users WHERE id = ?",
          "params": {"id": {"type": "int", "default": None}},
      },
  ]


  chat_with_sql = ChatWithSQL(
      database_url=database_url,
      llm=llm,
      model=model_name,
      llm_api_key=api_key,
      query_schema=query_schema,
  )
  ```



  Use the `execute_query` method to process a natural language prompt and retrieve data:

  ```python
  prompt = "Show me the details of the user with ID 5."
  response = chat_with_sql.execute_query(prompt)
  print(response)
  ```




  ChatWithSQL mitigates one of the largest risks of Text-to-SQL systems: **arbitrary query execution**. It employs schema-based validation to restrict query generation within pre-defined parameters. SQL queries are dynamically constructed and validated, ensuring:

  1. Queries are limited to schema-defined structures.
  2. Parameters are sanitized and validated against expected types.
  3. Arbitrary query execution by LLMs is entirely eliminated.




  - **OpenAI** (e.g., GPT-4, GPT-3.5)
  - **Gemini**
  - **LlamaAPI**
  - **Ollama**







  ```python
  ChatWithSQL(
      database_url: str,
      llm: str,
      model: Optional[str] = "",
      llm_api_key: Optional[str] = None,
      query_schema: Optional[List[Dict[str, Any]]] = None,
  )
  ```
  - **`database_url`**: Connection URI for the database.
  - **`llm`**: Type of LLM to use (`gemini`, `openai`, `llama_api`, `ollama`).
  - **`model`**: LLM model name.
  - **`llm_api_key`**: API key for accessing the LLM.
  - **`query_schema`**: List of schema definitions, each with `description`, `name`, `sql`, and `params`.


  Executes a natural language query and retrieves data.
  - **`prompt`**: Natural language request.
  - **Returns**: Query results as a dictionary.




  The `query_schema` parameter ensures secure and structured interactions. Each schema item includes:
  - **`description`**: Human-readable description of the query.
  - **`name`**: Unique name of the query.
  - **`sql`**: SQL query template with placeholders (`?`) for parameters.
  - **`params`**: Dictionary defining parameters with:
    - `type`: Data type (`str`, `int`, `float`, `date`, `datetime`).
    - `default`: Specify the default value for the parameter or if it can be any value, indicate it as null.

  Example:
  ```json
  [
      {
          "description": "Fetch user details by ID",
          "name": "get_user_details",
          "sql": "SELECT * FROM users WHERE id = ?",
          "params": {"id": {"type": "int", "default": null}}
      },
      {
          "description": "Fetch user details by DOB",
          "name": "get_user_details_by_dob",
          "sql": "SELECT * FROM users WHERE dob = ?",
          "params": {"dob": {"type": "date", "default": null}}
      }
  ]
  ```




  ChatWithSQL includes extensive logging for better observability:
  - Logs parameter validation errors.
  - Logs malformed prompts or unexpected results from the LLM.
  - Tracks query construction and database execution.

  Enable logging by configuring Python’s `logging` module.




  Contributions are welcome! Please submit a pull request or open an issue on our [GitHub Repository](https://github.com/sathninduk/ChatWithSQL).




  ChatWithSQL is open-source software licensed under the MIT License.




  If you have any questions or issues, feel free to contact us at [hello@bysatha.com](mailto:hello@bysatha.com) or open a GitHub issue.


pkgId: 87bf287c88086769e49f29afc5c8f4e10a7f8aec3c364663eca785c6de58376f
name: python-chaussette
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A WSGI Server for Circus
url: http://chaussette.readthedocs.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chaussette-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Chaussette is a WSGI server. The particularity of Chaussette is that
  it can either bind a socket on a port like any other server does or
  run against already opened sockets.
  That makes Chaussette the best companion to run a WSGI or Django_ stack
  under a process and socket manager, such as Circus_.


pkgId: 413ed96bd69ec90a74e9369cd0ae6a7b751fe4f231cbd1d38568a784284785b3
name: python-chck
arch: src
version: 0.0.75
epoch: 0
release: 1
summary: chck
url: https://github.com/dsm-72/chck
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chck-0.0.75-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->





  ``` sh

  $ mamba env create -f env.yml


  $ mamba env update -n chck --file env.yml
  ```



  ``` sh
  pip install -e .


  pip install chck
  ```



  ``` sh

  $ conda activate chck


  $ pip install -e .





  $ nbdev_prepare
  ```



  ``` sh

  $ nbdev_pypi


  $ nbdev_conda --build_args '-c conda-forge'
  $ nbdev_conda --mambabuild --build_args '-c conda-forge -c dsm-72'
  ```





  Install latest from the GitHub
  [repository](https://github.com/dsm-72/chck):

  ``` sh
  $ pip install git+https://github.com/dsm-72/chck.git
  ```

  or from [conda](https://anaconda.org/dsm-72/chck)

  ``` sh
  $ conda install -c dsm-72 chck
  ```

  or from [pypi](https://pypi.org/project/chck/)

  ``` sh
  $ pip install chck
  ```



  Documentation can be found hosted on GitHub
  [repository](https://github.com/dsm-72/chck)
  [pages](https://dsm-72.github.io/chck/). Additionally you can find
  package manager specific guidelines on
  [conda](https://anaconda.org/dsm-72/chck) and
  [pypi](https://pypi.org/project/chck/) respectively.


pkgId: f5bba0d1573a01402a02df78ee74dda13996d205a2e89d3e6ca5456d7fe81740
name: python-chdb
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: chDB is an in-process SQL OLAP Engine powered by ClickHouse
url: https://github.com/chdb-io/chdb
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chdb-2.0.4-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
     <a href="https://clickhouse.com/blog/chdb-joins-clickhouse-family">📢 chDB joins the ClickHouse family 🐍+🚀</a>
  </div>
  <div align="center">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/chdb-io/chdb/raw/main/docs/_static/snake-chdb-dark.png" height="130">
    <img src="https://github.com/chdb-io/chdb/raw/main/docs/_static/snake-chdb.png" height="130">
  </picture>

  [![Build X86](https://github.com/chdb-io/chdb/actions/workflows/build_linux_x86_wheels.yml/badge.svg?event=release)](https://github.com/chdb-io/chdb/actions/workflows/build_linux_x86_wheels.yml)
  [![PyPI](https://img.shields.io/pypi/v/chdb.svg)](https://pypi.org/project/chdb/)
  [![Downloads](https://static.pepy.tech/badge/chdb)](https://pepy.tech/project/chdb)
  [![Discord](https://img.shields.io/discord/1098133460310294528?logo=Discord)](https://discord.gg/D2Daa2fM5K)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/chdb_io)
  </div>




  > chDB is an in-process SQL OLAP Engine powered by ClickHouse  [^1]
  > For more details: [The birth of chDB](https://auxten.com/the-birth-of-chdb/)




  * In-process SQL OLAP Engine, powered by ClickHouse
  * No need to install ClickHouse
  * Minimized data copy from C++ to Python with [python memoryview](https://docs.python.org/3/c-api/memoryview.html)
  * Input&Output support Parquet, CSV, JSON, Arrow, ORC and 60+[more](https://clickhouse.com/docs/en/interfaces/formats) formats, [samples](tests/format_output.py)
  * Support Python DB API 2.0, [example](examples/dbapi.py)




  <div align="center">
    <img src="https://github.com/chdb-io/chdb/raw/main/docs/_static/arch-chdb2.png" width="450">
  </div>


  Get started with **chdb** using our [Installation and Usage Examples](https://clickhouse.com/docs/en/chdb)

  <br>


  Currently, chDB supports Python 3.8+ on macOS and Linux (x86_64 and ARM64).
  ```bash
  pip install chdb
  ```




  > `python3 -m chdb SQL [OutputFormat]`
  ```bash
  python3 -m chdb "SELECT 1,'abc'" Pretty
  ```

  <br>


  The following methods are available to access on-disk and in-memory data formats:

  <details>
      <summary><h4>🗂️ Query On File</h4> (Parquet, CSV, JSON, Arrow, ORC and 60+)</summary>

  You can execute SQL and return desired format data.

  ```python
  import chdb
  res = chdb.query('select version()', 'Pretty'); print(res)
  ```


  ```python

  res = chdb.query('select * from file("data.parquet", Parquet)', 'JSON'); print(res)
  res = chdb.query('select * from file("data.csv", CSV)', 'CSV');  print(res)
  print(f"SQL read {res.rows_read()} rows, {res.bytes_read()} bytes, elapsed {res.elapsed()} seconds")
  ```


  ```python

  chdb.query('select * from file("data.parquet", Parquet)', 'Dataframe')
  ```
  </details>

  <details>
      <summary><h4>🗂️ Query On Table</h4> (Pandas DataFrame, Parquet file/bytes, Arrow bytes) </summary>


  ```python
  import chdb.dataframe as cdf
  import pandas as pd

  df1 = pd.DataFrame({'a': [1, 2, 3], 'b': ["one", "two", "three"]})
  df2 = pd.DataFrame({'c': [1, 2, 3], 'd': ["①", "②", "③"]})
  ret_tbl = cdf.query(sql="select * from __tbl1__ t1 join __tbl2__ t2 on t1.a = t2.c",
                    tbl1=df1, tbl2=df2)
  print(ret_tbl)

  print(ret_tbl.query('select b, sum(a) from __table__ group by b'))
  ```
  </details>

  <details>
    <summary><h4>🗂️ Query with Stateful Session</h4></summary>

  ```python
  from chdb import session as chs


  sess = chs.Session()
  sess.query("CREATE DATABASE IF NOT EXISTS db_xxx ENGINE = Atomic")
  sess.query("CREATE TABLE IF NOT EXISTS db_xxx.log_table_xxx (x String, y Int) ENGINE = Log;")
  sess.query("INSERT INTO db_xxx.log_table_xxx VALUES ('a', 1), ('b', 3), ('c', 2), ('d', 5);")
  sess.query(
      "CREATE VIEW db_xxx.view_xxx AS SELECT * FROM db_xxx.log_table_xxx LIMIT 4;"
  )
  print("Select from view:\n")
  print(sess.query("SELECT * FROM db_xxx.view_xxx", "Pretty"))
  ```

  see also: [test_stateful.py](tests/test_stateful.py).
  </details>

  <details>
      <summary><h4>🗂️ Query with Python DB-API 2.0</h4></summary>

  ```python
  import chdb.dbapi as dbapi
  print("chdb driver version: {0}".format(dbapi.get_client_info()))

  conn1 = dbapi.connect()
  cur1 = conn1.cursor()
  cur1.execute('select version()')
  print("description: ", cur1.description)
  print("data: ", cur1.fetchone())
  cur1.close()
  conn1.close()
  ```
  </details>


  <details>
      <summary><h4>🗂️ Query with UDF (User Defined Functions)</h4></summary>

  ```python
  from chdb.udf import chdb_udf
  from chdb import query

  @chdb_udf()
  def sum_udf(lhs, rhs):
      return int(lhs) + int(rhs)

  print(query("select sum_udf(12,22)"))
  ```

  Some notes on chDB Python UDF(User Defined Function) decorator.
  1. The function should be stateless. So, only UDFs are supported, not UDAFs(User Defined Aggregation Function).
  2. Default return type is String. If you want to change the return type, you can pass in the return type as an argument.
      The return type should be one of the following: https://clickhouse.com/docs/en/sql-reference/data-types
  3. The function should take in arguments of type String. As the input is TabSeparated, all arguments are strings.
  4. The function will be called for each line of input. Something like this:
      ```
      def sum_udf(lhs, rhs):
          return int(lhs) + int(rhs)

      for line in sys.stdin:
          args = line.strip().split('\t')
          lhs = args[0]
          rhs = args[1]
          print(sum_udf(lhs, rhs))
          sys.stdout.flush()
      ```
  5. The function should be pure python function. You SHOULD import all python modules used IN THE FUNCTION.
      ```
      def func_use_json(arg):
          import json
          ...
      ```
  6. Python interpertor used is the same as the one used to run the script. Get from `sys.executable`

  see also: [test_udf.py](tests/test_udf.py).
  </details>


  <details>
      <summary><h4>🗂️ Python Table Engine</h4></summary>



  ```python
  import chdb
  import pandas as pd
  df = pd.DataFrame(
      {
          "a": [1, 2, 3, 4, 5, 6],
          "b": ["tom", "jerry", "auxten", "tom", "jerry", "auxten"],
      }
  )

  chdb.query("SELECT b, sum(a) FROM Python(df) GROUP BY b ORDER BY b").show()
  ```



  ```python
  import chdb
  import pyarrow as pa
  arrow_table = pa.table(
      {
          "a": [1, 2, 3, 4, 5, 6],
          "b": ["tom", "jerry", "auxten", "tom", "jerry", "auxten"],
      }
  )

  chdb.query(
      "SELECT b, sum(a) FROM Python(arrow_table) GROUP BY b ORDER BY b", "debug"
  ).show()
  ```



  1. You must inherit from chdb.PyReader class and implement the `read` method.
  2. The `read` method should:
      1. return a list of lists, the first demension is the column, the second dimension is the row, the columns order should be the same as the first arg `col_names` of `read`.
      1. return an empty list when there is no more data to read.
      1. be stateful, the cursor should be updated in the `read` method.
  3. An optional `get_schema` method can be implemented to return the schema of the table. The prototype is `def get_schema(self) -> List[Tuple[str, str]]:`, the return value is a list of tuples, each tuple contains the column name and the column type. The column type should be one of the following: https://clickhouse.com/docs/en/sql-reference/data-types

  ```python
  import chdb

  class myReader(chdb.PyReader):
      def __init__(self, data):
          self.data = data
          self.cursor = 0
          super().__init__(data)

      def read(self, col_names, count):
          print("Python func read", col_names, count, self.cursor)
          if self.cursor >= len(self.data["a"]):
              return []
          block = [self.data[col] for col in col_names]
          self.cursor += len(block[0])
          return block

  reader = myReader(
      {
          "a": [1, 2, 3, 4, 5, 6],
          "b": ["tom", "jerry", "auxten", "tom", "jerry", "auxten"],
      }
  )

  chdb.query(
      "SELECT b, sum(a) FROM Python(reader) GROUP BY b ORDER BY b"
  ).show()
  ```

  see also: [test_query_py.py](tests/test_query_py.py).



  1. Column types supported: pandas.Series, pyarrow.array, chdb.PyReader
  1. Data types supported: Int, UInt, Float, String, Date, DateTime, Decimal
  1. Python Object type will be converted to String
  1. Pandas DataFrame performance is all of the best, Arrow Table is better than PyReader


  </details>

  For more examples, see [examples](examples) and [tests](tests).

  <br>



  - [Project Documentation](https://clickhouse.com/docs/en/chdb) and [Usage Examples](https://clickhouse.com/docs/en/chdb/install/python)
  - [Colab Notebooks](https://colab.research.google.com/drive/1-zKB6oKfXeptggXi0kUX87iR8ZTSr4P3?usp=sharing) and other [Script Examples](examples)



  - [ClickBench of embedded engines](https://benchmark.clickhouse.com/#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)

  - [chDB vs Pandas](https://colab.research.google.com/drive/1FogLujJ_-ds7RGurDrUnK-U0IW8a8Qd0)

  <div align="center">
      <img src="https://github.com/chdb-io/chdb/raw/main/docs/_static/chdb-vs-pandas.jpg" width="800">
  </div>



  - For chdb specific examples and documentation refer to [chDB docs](https://clickhouse.com/docs/en/chdb)
  - For SQL syntax, please refer to [ClickHouse SQL Reference](https://clickhouse.com/docs/en/sql-reference/syntax)




  - Demo chDB at [ClickHouse v23.7 livehouse!](https://t.co/todc13Kn19) and [Slides](https://docs.google.com/presentation/d/1ikqjOlimRa7QAg588TAB_Fna-Tad2WMg7_4AgnbQbFA/edit?usp=sharing)


  Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.
  There are something you can help:
  - [ ] Help test and report bugs
  - [ ] Help improve documentation
  - [ ] Help improve code quality and performance



  We welcome bindings for other languages, please refer to [bindings](bindings.md) for more details.


  Apache 2.0, see [LICENSE](LICENSE.txt) for more information.


  chDB is mainly based on [ClickHouse](https://github.com/ClickHouse/ClickHouse) [^1]
  for trade mark and other reasons, I named it chDB.


  - Discord: [https://discord.gg/D2Daa2fM5K](https://discord.gg/D2Daa2fM5K)
  - Email: auxten@clickhouse.com
  - Twitter: [@chdb](https://twitter.com/chdb_io)


  <br>

  [^1]: ClickHouse® is a trademark of ClickHouse Inc. All trademarks, service marks, and logos mentioned or depicted are the property of their respective owners. The use of any third-party trademarks, brand names, product names, and company names does not imply endorsement, affiliation, or association with the respective owners.


pkgId: 46f78273495517e54ece7d2387f1d614b78bedf20550043615c021f0967cfa96
name: python-cheap-repr
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Better version of repr/reprlib for short, cheap string representations.
url: https://github.com/alexmojaki/cheap_repr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheap-repr-0.5.2-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/alexmojaki/cheap_repr/actions/workflows/pytest.yml/badge.svg)](https://github.com/alexmojaki/cheap_repr/actions/workflows/pytest.yml) [![Coverage Status](https://coveralls.io/repos/github/alexmojaki/cheap_repr/badge.svg?branch=master)](https://coveralls.io/github/alexmojaki/cheap_repr?branch=master) [![Supports Python versions 3.8+](https://img.shields.io/pypi/pyversions/cheap_repr.svg)](https://pypi.python.org/pypi/cheap_repr)
  This library provides short, fast, configurable string representations, and an easy API for registering your own. It's an improvement of the standard library module `reprlib` (`repr` in Python 2).
  Just use the `cheap_repr` function instead of `repr`:
  ```python
  >>> from cheap_repr import cheap_repr
  >>> cheap_repr(list(range(100)))
  '[0, 1, 2, ..., 97, 98, 99]'
  ```
  `cheap_repr` knows how to handle many different types out of the box. You can register a function for any type, and pull requests to make these part of the library are welcome. If it doesn't know how to handle a particular type, the default `repr()` is used, possibly truncated:
  ```python
  >>> class MyClass(object):
  >>> c = MyClass(list(range(20)))
  >>> c
  MyClass([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
  >>> cheap_repr(c)
  'MyClass([0, 1, 2, 3, 4, 5, 6... 13, 14, 15, 16, 17, 18, 19])'
  ```

  `cheap_repr` is meant to prevent slow, expensive computations of string representations. So if it finds that a particular class can potentially produce very long representations, the class will be *suppressed*, meaning that in future the  `__repr__` won't be calculated at all:
  ```python
  >>> cheap_repr(MyClass(list(range(1000))))
  'MyClass([0, 1, 2, 3, 4, 5, 6...94, 995, 996, 997, 998, 999])'
  >>> cheap_repr(MyClass(list(range(1000))))
  '<MyClass instance at 0x1034de7f0 (repr suppressed)>'
  ```
  `cheap_repr.suppression_threshold` refers to the attribute on the function itself, not the module. By default it's 300, meaning that a `repr` longer than 300 characters will trigger the suppression.

  For example:
  ```python
  >>> from cheap_repr import register_repr
  >>> @register_repr(MyClass)
  >>> cheap_repr(MyClass(list(range(1000))))
  'MyClass([0, 1, 2, 3, 4, 5, ...])'
  ```
  In general, write a function that takes two arguments `(x, helper)` and decorate it with `register_repr(cls)`. Then `cheap_repr(x)` where `isinstance(x, cls)` will dispatch to that function, unless there is also a registered function for a subclass which `x` is also an instance of. More precisely, the function corresponding to the first class in the MRO will be used. This is in contrast to the standard library module `reprlib`, which cannot handle subclasses that aren't explicitly 'registered', or classes with the same name.
  The `helper` argument is an object with a couple of useful attributes and methods:
  - `repr_iterable(iterable, left, right, end=False, length=None)` produces a comma-separated representation of `iterable`, automatically handling nesting and iterables that are too long, surrounded by `left` and `right`. The number of items is limited to `func.maxparts` (see the configuration section below).
     Set `end=True` to include items from both the beginning and end, possibly leaving out items
   in the middle. Only do this if `iterable` supports efficient slicing at the end, e.g. `iterable[-3:]`.
      Provide the `length` parameter if `len(iterable)` doesn't work. Usually this is not needed.
  - `truncate(string)` returns a version of `string` at most `func.maxparts` characters long, with the middle replaced by `...` if necessary.
  - `level` indicates how much nesting is still allowed in the result. If it's 0, return something minimal such as `[...]` to indicate that the original object is too deep to show all its contents. Otherwise, if you use `cheap_repr` on several items inside `x`, pass `helper.level - 1` as the second argument, e.g. `', '.join(cheap_repr(item, helper.level - 1) for item in x)`.

  If an exception occurs in `cheap_repr`, whether from a registered repr function or the usual `__repr__`, the exception will be caught and the cheap repr of the class will be suppressed:
  ```python
  >>> @register_repr(MyClass)
  >>> cheap_repr(MyClass([]))
  '<MyClass instance at 0x10f44ec50 (exception in repr)>'
  >>> cheap_repr(MyClass([1, 2, 3]))
  '<MyClass instance at 0x10f44ecc0 (repr suppressed)>'
  ```
  If you would prefer exceptions to bubble up normally, you can:
  1. Set `cheap_repr.raise_exceptions = True` to globally make all exceptions bubble up.
  2. To bubble exceptions from the `__repr__` of a class, call `raise_exceptions_from_default_repr()`.
  3. Set `repr_my_class.raise_exceptions = True` (substituting your own registered repr function) to make exceptions bubble from that function. The way to find the relevant function is in the next section.


  To configure a specific function, you set attributes on that function. To find the function corresponding to a class, use `find_repr_function`:
  ```python
  >>> from cheap_repr import find_repr_function
  >>> find_repr_function(MyClass)
  <function repr_my_class at 0x10f43d8c8>
  ```
  For most functions, there are two attributes available to configure, but contributors and library writers are encouraged to add arbitrary attributes for their own functions. The first attribute is `raise_exceptions`, described in the previous section.

  The other configurable attribute is `maxparts`. All registered repr functions have this attribute. It determines the maximum number of 'parts' (e.g. list elements or string characters, the meaning depends on the function) from the input that the output can display without truncation. The default value is 6. The decorator `@maxparts(n)` conveniently sets the attribute to make writing your own registered functions nicer. For example:
  ```python
  >>> from cheap_repr import maxparts
  >>> @register_repr(MyClass)
  >>> cheap_repr(MyClass([1, 2, 3, 4]))
  'MyClass([1, 2, ...])'
  >>> find_repr_function(MyClass).maxparts = 3
  >>> cheap_repr(MyClass([1, 2, 3, 4]))
  'MyClass([1, 2, 3, ...])'
  ```

  The functions for `DataFrame`s and `Series` from the `pandas` library don't use `maxparts`.
  For the `DataFrame` function there's `max_rows` and `max_cols`. For the `Series` function there's just `max_rows`.

  `cheap_repr` takes an optional argument `level` which controls the display of nested objects. Typically this decreases through recursive calls, and when it's 0, the contents of the object aren't shown. See 'Registering your own repr function' for more details. This means you can change the amount of nested data in the output of `cheap_repr` by changing the `level` argument. The default value is `cheap_repr.max_level`, which is initially 3. This means that changing `cheap_repr.max_level` will effectively change the `level` argument whenever it isn't explicitly specified.

  These things that can be configured globally:
  1. `cheap_repr.suppression_threshold`, discussed in the 'Suppression of long reprs' section.
  2. The handling of exceptions, discussed in the 'Exceptions in repr functions' section, which can be changed by setting `cheap_repr.raise_exceptions = True` or calling `raise_exceptions_from_default_repr()`.
  3. `cheap_repr.max_level`, discussed above.

  `basic_repr(x)` returns a string that looks like the default `object.__repr__`. This is handy if you don't want to write your own repr function to register. Simply register this function instead, e.g.
  ```python
  >>> from cheap_repr import basic_repr
  >>> register_repr(MyClass)(basic_repr)
  >>> cheap_repr(MyClass([1, 2, 3, 4]))
  '<MyClass instance at 0x10f39dda0>'
  ```
  `normal_repr(x)` returns `repr(x)` - register it with a class to indicate that its own `__repr__` method is already fine. This prevents it from being supressed when its output is a bit long.
  `try_register_repr` is handy when you want to register a repr function for a class that may not exist, e.g. if the class is in a third party package that may not be installed. See the docstring for more details.


pkgId: a04017d8f32783ef0fde9298c29ac62a1aaf044ef7ab32ed5bc3678b83be6164
name: python-cheat
arch: src
version: 2.5.1
epoch: 0
release: 1
url: https://github.com/chrisallenlane/cheat
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheat-2.5.1-1.src.rpm
checksum_type: sha256
summary:
  cheat allows you to create and view interactive cheatsheets on the command-line. It was designed to help remind *nix system administrators of options for commands that they use frequently, but not frequently enough to remember.


pkgId: 49941dff974d5e23f4930584eff6c50b17f16e2fe2f189eafc612e4bab37cb33
name: python-cheat-chat
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A server-client chat application with Redis and MySQL support
url: https://github.com/MesudeTurkmen/cheat_chat
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheat-chat-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A Python-based chat application using Redis and MySQL.


  working on that


  Abdullah Zeynel & Zeren Kavaz & Kerem Durgut & Mesude TÃ¼rkmen


pkgId: 70bac8a906e7b91e562b006681b6af34fc5762de1ab91ccaa98c7df2eb9ba169
name: python-check-bump
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Check if pyproject.toml version was bumped
url: https://github.com/rgryta/Check-Bump
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-bump-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center"></p>
  <h2 align="center">Check Bump</h2>
  <p align="center">
  <a href="https://github.com/rgryta/Check-Bump/actions/workflows/main.yml"><img alt="Build" src="https://github.com/rgryta/Check-Bump/actions/workflows/main.yml/badge.svg?branch=main"></a>
  <a href="https://pypi.org/project/check-bump/"><img alt="PyPI" src="https://img.shields.io/pypi/v/check-bump"></a>
  <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  <a href="https://github.com/PyCQA/pylint"><img alt="pylint" src="https://img.shields.io/badge/linting-pylint-yellowgreen"></a>
  <a href="https://github.com/rgryta/NoPrint"><img alt="NoPrint" src="https://img.shields.io/badge/NoPrint-enabled-blueviolet"></a>
  </p>



  Want to add version bump checks to your CI/CD pipeline? This packages makes it easy.
  Simply execute `check-bump` within a directory where your `pyproject.toml` is located.

  If there was a version bump, process will finish with exit code 0 - read stdout for the new version.
  Otherwise, process will finish with exit code 1.



  This package requires `tomlkit` package.





  Simply execute `check-bump` within a directory where your `pyproject.toml` is located. Or provide a path using `--path` argument.

  ```bash
  user$ check-bump --help
  usage: check-bump [-h] {toml,regex,touch} ...

  Detect and retrieve version bump

  options:
    -h, --help          show this help message and exit

  Methods:
    {toml,regex,touch}  Different methods for parsing files
      toml              Parsing toml file
      regex             Regex file parsing
      touch             Touch file check
  ```







  **Required** Select which method to use for detecting version bumps.



  **Optional** Relative path of versioning file. Example: `'python_src/pyproject.toml'`



  **Optional** Prefix to provide for version output. Example: `'v'`





  **always** Whether there was a bump or not. Values: `'true'`|`'false'`



  **optional** Current (if bumped) version with prefix. If there was no version bump - no output is provided.



  ```yml
  - name: Check bump
    id: vbump
    uses: rgryta/Check-Bump@main
    with:
      method: 'toml'
      prefix: 'v'
  ```

  And then you can later reference like:
  ```yml
  - name: Tag repository
    if: steps.vbump.outputs.bump == 'true'
    run: |
      echo "I was bumped to version: ${{ steps.vbump.outputs.version }}"
  ```





  Install virtual environment and check_bump package in editable mode with dev dependencies.

  ```bash
  python -m venv venv
  source venv/bin/activate
  pip install -e .[dev]
  ```




  Automate as much as we can, see configuration in `pyproject.toml` file to see what are the flags used.

  ```bash
  staging format  # Reformat the code
  staging lint    # Check for linting issues
  staging test    # Run unit tests and coverage report
  ```


pkgId: bfd3a3623a8442c996fa8390a4fba1feee978a96929510373edf3b7859e10c01
name: python-check-cmake
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A simple linter for CMake.
url: https://pypi.org/project/check-cmake/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-cmake-0.5.1-1.src.rpm
checksum_type: sha256
description:
  A simple linter for CMake.



  `check-cmake` requires Python 3.8 or higher.

  ```
  pip3 install check-cmake
  ```



  `check-cmake` is a command-line application

  ```
  usage: check-cmake [-h] [-v] [--version] [--recurse | --no-recurse] [--limit LIMIT] [root]

  CMake checker for C and C++ projects.

  positional arguments:
    root                  path to the project root (default: .)

  options:
    -h, --help            show this help message and exit
    -v, --verbose         enable verbose output
    --version             print the version and exit
    --recurse, --no-recurse
                          recurse into subfolders (default: True)
    --limit LIMIT         maximum errors to emit (default: 0)

  v0.3.0 - github.com/marzer/check-cmake
  ```



  | Value                                | Meaning                        |
  | :----------------------------------- | :----------------------------- |
  | 0                                    | No issues were found           |
  | `N`, where `N` is a positive integer | `N` issues were found in total |
  | -1                                   | A fatal error occurred         |



  ```
  error: /my_lib/CMakeLists.txt:29:9: language standard level should be set on a per-target basis using target_compile_features()
    Context:
      29 | set_target_properties(
      30 |     my_lib
      31 |     PROPERTIES
      32 |         CXX_STANDARD 14
      33 |         CXX_STANDARD_REQUIRED ON
      34 |         CXX_EXTENSIONS OFF
      35 | )
    Replace with:
      target_compile_features(): https://cmake.org/cmake/help/latest/command/target_compile_features.html
    More information:
      CMAKE_CXX_KNOWN_FEATURES: https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_CXX_KNOWN_FEATURES.html
      CMAKE_C_KNOWN_FEATURES: https://cmake.org/cmake/help/latest/prop_gbl/CMAKE_C_KNOWN_FEATURES.html

  found 1 error in 1 file.
  ```



  Checks can be suppressed using comment-based 'pragmas' at the end of the source line:

  ```cmake
  set_target_properties(
      my_lib
      PROPERTIES
          CXX_STANDARD 14 # nocheck
          CXX_STANDARD_REQUIRED ON
          CXX_EXTENSIONS OFF
  )
  ```

  For compatibility with other tools, any the following will also work:

  ```cmake





















  ```





  - Fixed false positive for incorrect use of `SYSTEM` in `target_include_directories()` in some cases



  - Added check for `add_library()` with implicit type (`STATIC`, `SHARED`, et cetera)



  - Fixed line numbers sometimes being wrong in context snippets
  - Added check for incorrectly-placed `SYSTEM` in `target_include_directories()`
  - Added check for extraneous space in `ExternalProject_Add()` `CMAKE_ARGS`



  - Fixed `#nocheck`



  - Added pragmas for ignoring checks on a line
  - Added check for `cmake_minimum_required()` when `project()` is present
  - Fixed minor formatting issues



  - First public release 🎉&#xFE0F;


pkgId: 39c6be17dea8797b8a2af12477e86c5ce934ca4748adb1ee262d0f071e00b157
name: python-check-if-nan
arch: src
version: 0.11
epoch: 0
release: 1
summary: Checks for all kinds of nan/None values without raising Exceptions all the time
url: https://github.com/hansalemaos/check_if_nan
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-if-nan-0.11-1.src.rpm
checksum_type: sha256
description:
  ```python
  from check_if_nan import is_nan,sort_nan_non_nan
  import numpy as np
  import pandas as pd
  import math
  a = None
  b = pd.NA
  c = np.nan
  d = math.nan
  e = float("nan")
  f = []
  g = np.array([])
  h = dict()
  i = tuple()
  j = set()
  k = ""
  l = "NaN"
  m = b""
  n = bytearray()


  print("a", is_nan(a))
  print("b", is_nan(b))
  print("c", is_nan(c))
  print("d", is_nan(d))
  print("e", is_nan(e))
  print("f", is_nan(f))
  print("g", is_nan(g))
  print("h", is_nan(h))
  print("i", is_nan(i))
  print("j", is_nan(j))
  print("k", is_nan(k))
  print("l", is_nan(l))
  print("m", is_nan(m))
  print("n", is_nan(n))

  print("f", is_nan(f, emptyiters=True))
  print("g", is_nan(g, emptyiters=True))
  print("h", is_nan(h, emptyiters=True))
  print("i", is_nan(i, emptyiters=True))
  print("j", is_nan(j, emptyiters=True))
  print("k", is_nan(k, emptystrings=True))
  print("l", is_nan(l, nastrings=True))
  print("m", is_nan(m, emptybytes=True))
  print("n", is_nan(n, emptyiters=True))


  a True
  b True
  c True
  d True
  e True
  f False
  g False
  h False
  i False
  j False
  k False
  l False
  m False
  n False


  f True
  g True
  h True
  i True
  j True
  k True
  l True
  m True
  n True


  sor = sort_nan_non_nan(
      seq=[a, b, c, d, e, f, g, h, i, j, k, l, m, n],
      emptyiters=False,
      nastrings=False,
      emptystrings=False,
      emptybytes=False,
  )
  print(sor)





  sor = sort_nan_non_nan(
      seq=[a, b, c, d, e, f, g, h, i, j, k, l, m, n],
      emptyiters=True,
      nastrings=False,
      emptystrings=False,
      emptybytes=False,
  )
  print(sor)






  sor = sort_nan_non_nan(
      seq=[a, b, c, d, e, f, g, h, i, j, k, l, m, n],
      emptyiters=True,
      nastrings=False,
      emptystrings=True,
      emptybytes=True,
  )
  print(sor)




  sor = sort_nan_non_nan(
      seq=[a, b, c, d, e, f, g, h, i, j, k, l, m, n],
      emptyiters=True,
      nastrings=True,
      emptystrings=True,
      emptybytes=True,
  )
  print(sor)



  ```


pkgId: 3c054029b87dfbc5150c2e09d86ffcb2ad97b1904b678d76d8ef47e2b4a7f483
name: python-check-jsonschema
arch: src
version: 0.29.2
epoch: 0
release: 1
summary: A jsonschema CLI and pre-commit hook
url: https://github.com/python-jsonschema/check-jsonschema
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-jsonschema-0.29.2-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/check-jsonschema.svg)](https://pypi.org/project/check-jsonschema/)
  [![supported pythons](https://img.shields.io/pypi/pyversions/check-jsonschema.svg)](https://pypi.org/project/check-jsonschema/)
  [![build](https://github.com/python-jsonschema/check-jsonschema/actions/workflows/build.yaml/badge.svg)](https://github.com/python-jsonschema/check-jsonschema/actions/workflows/build.yaml)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/python-jsonschema/check-jsonschema/main.svg)](https://results.pre-commit.ci/latest/github/python-jsonschema/check-jsonschema/main)
  [![readthedocs documentation](https://readthedocs.org/projects/check-jsonschema/badge/?version=stable&style=flat)](https://check-jsonschema.readthedocs.io/en/stable)




  A JSON Schema CLI and [pre-commit](https://pre-commit.com/) hook built on [jsonschema](https://github.com/python-jsonschema/jsonschema/).
  The schema may be specified as a local or remote (HTTP or HTTPS) file.

  Remote files are automatically downloaded and cached if possible.



  `check-jsonschema` can be installed and run as a CLI tool, or via pre-commit.



  The following configuration uses `check-jsonschema` to validate Github Workflow
  files.

  ```yaml
  - repo: https://github.com/python-jsonschema/check-jsonschema
    rev: 0.29.2
    hooks:
      - id: check-github-workflows
        args: ["--verbose"]
  ```



  Install with `pipx` or `brew`:

      pipx install check-jsonschema

  or

      brew install check-jsonschema

  Then run, as in

      check-jsonschema --schemafile schema.json instance.json



  Full documentation can be found at https://check-jsonschema.readthedocs.io/


pkgId: de5982dc611ac190fed6521e9377f0002c3787b0987ee0caf2904fd897245379
name: python-check-jsonschema
arch: src
version: 0.29.3
epoch: 0
release: 1
summary: A jsonschema CLI and pre-commit hook
url: https://github.com/python-jsonschema/check-jsonschema
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-jsonschema-0.29.3-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/check-jsonschema.svg)](https://pypi.org/project/check-jsonschema/)
  [![supported pythons](https://img.shields.io/pypi/pyversions/check-jsonschema.svg)](https://pypi.org/project/check-jsonschema/)
  [![build](https://github.com/python-jsonschema/check-jsonschema/actions/workflows/build.yaml/badge.svg)](https://github.com/python-jsonschema/check-jsonschema/actions/workflows/build.yaml)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/python-jsonschema/check-jsonschema/main.svg)](https://results.pre-commit.ci/latest/github/python-jsonschema/check-jsonschema/main)
  [![readthedocs documentation](https://readthedocs.org/projects/check-jsonschema/badge/?version=stable&style=flat)](https://check-jsonschema.readthedocs.io/en/stable)




  A JSON Schema CLI and [pre-commit](https://pre-commit.com/) hook built on [jsonschema](https://github.com/python-jsonschema/jsonschema/).
  The schema may be specified as a local or remote (HTTP or HTTPS) file.

  Remote files are automatically downloaded and cached if possible.



  `check-jsonschema` can be installed and run as a CLI tool, or via pre-commit.



  The following configuration uses `check-jsonschema` to validate Github Workflow
  files.

  ```yaml
  - repo: https://github.com/python-jsonschema/check-jsonschema
    rev: 0.29.3
    hooks:
      - id: check-github-workflows
        args: ["--verbose"]
  ```



  Install with `pipx` or `brew`:

      pipx install check-jsonschema

  or

      brew install check-jsonschema

  Then run, as in

      check-jsonschema --schemafile schema.json instance.json



  Full documentation can be found at https://check-jsonschema.readthedocs.io/


pkgId: c5272e80b7ecc1d9b048fec8db37a5bc5b799f85079c3eb9fdf402b3e16671ea
name: python-check-jsonschema
arch: src
version: 0.30.0
epoch: 0
release: 1
summary: A jsonschema CLI and pre-commit hook
url: https://github.com/python-jsonschema/check-jsonschema
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-jsonschema-0.30.0-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/check-jsonschema.svg)](https://pypi.org/project/check-jsonschema/)
  [![supported pythons](https://img.shields.io/pypi/pyversions/check-jsonschema.svg)](https://pypi.org/project/check-jsonschema/)
  [![build](https://github.com/python-jsonschema/check-jsonschema/actions/workflows/build.yaml/badge.svg)](https://github.com/python-jsonschema/check-jsonschema/actions/workflows/build.yaml)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/python-jsonschema/check-jsonschema/main.svg)](https://results.pre-commit.ci/latest/github/python-jsonschema/check-jsonschema/main)
  [![readthedocs documentation](https://readthedocs.org/projects/check-jsonschema/badge/?version=stable&style=flat)](https://check-jsonschema.readthedocs.io/en/stable)




  A JSON Schema CLI and [pre-commit](https://pre-commit.com/) hook built on [jsonschema](https://github.com/python-jsonschema/jsonschema/).
  The schema may be specified as a local or remote (HTTP or HTTPS) file.

  Remote files are automatically downloaded and cached if possible.



  `check-jsonschema` can be installed and run as a CLI tool, or via pre-commit.



  The following configuration uses `check-jsonschema` to validate Github Workflow
  files.

  ```yaml
  - repo: https://github.com/python-jsonschema/check-jsonschema
    rev: 0.30.0
    hooks:
      - id: check-github-workflows
        args: ["--verbose"]
  ```



  Install with `pipx` or `brew`:

      pipx install check-jsonschema

  or

      brew install check-jsonschema

  Then run, as in

      check-jsonschema --schemafile schema.json instance.json



  Full documentation can be found at https://check-jsonschema.readthedocs.io/


pkgId: 292bbd440c896e2e46b8ce7adabbbc3cce877783ae001ff48df8c9533bc0645c
name: python-check-manifest
arch: src
version: 0.49
epoch: 0
release: 1
summary: Check MANIFEST.in in a Python source package for completeness
url: https://github.com/mgedmin/check-manifest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-manifest-0.49-1.src.rpm
checksum_type: sha256
description:
  |buildstatus|_ |appveyor|_ |coverage|_
  Are you a Python developer?  Have you uploaded packages to the Python Package
  Index?  Have you accidentally uploaded *broken* packages with some files
  missing?  If so, check-manifest is for you.


pkgId: 009201bb7ec39e56dcb7b22600690d32ac4852a7f8d3804fb84623d5ed82ea67
name: python-check-oldies
arch: src
version: 0.8.10
epoch: 0
release: 1
summary: Warns about unattended branches and FIXME or TODO annotations
url: https://check-oldies.readthedocs.io/en/latest/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-oldies-0.8.10-1.src.rpm
checksum_type: sha256
description:
      $ check-fixmes
      NOK: Some annotations are too old, or there are orphan FUTURE tags.
      jdoe            -  181 days - frobulator/api.py:12: # FIXME (jdoe): we should catch errors
      jdoe            -  100 days - frobulator/api.py:25: # TODO: this is slow, use the batch API instead
      jsmith          -   12 days - docs/index.rst:1: # FIXME: write documentation before open sourcing
      $ check-branches
      NOK: Some branches are too old.
      john.smith@example.com     -   92 days - jsmith/fix_frobs (https://github.com/Polyconseil/check-oldies/tree/jsmith/fix_frobs), linked to open PR/MR #1 (https://github.com/Polyconseil/check-oldies/pull/1)


pkgId: 54274b9cf986cf7e9cc6667b27880cef7f42eebf4dac092a378d63c783941ea7
name: python-check-python-versions
arch: src
version: 0.22.1
epoch: 0
release: 1
summary: Compare supported Python versions in setup.py vs tox.ini et al.
url: https://github.com/mgedmin/check-python-versions
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-python-versions-0.22.1-1.src.rpm
checksum_type: sha256
description:
  This is a tool for Python package maintainers who want to explicitly state
  which Python versions they support.
  **The problem**: to properly support e.g. Python 2.7 and 3.6+ you have to
  run tests with these Pythons.  This means
  - you need a tox.ini with envlist = py27, py36, py37, py38, py39
  - you need a .travis.yml with python: [ 2.7, 3.6, 3.7, 3.8, 3.9 ]
  - if you support Windows, you need an appveyor.yml with %PYTHON% set to
    C:\\Python2.7, C:\\Python3.5, and so on
  - if you're building manylinux wheels you need to ... you get the idea
  - you have to tell the users which Python versions you support by specifying
    trove classifiers like "Programming Language :: Python :: 2.7"
  - you probably also want to tell pip which versions you support by specifying
    python_requires=">= 2.7, !=3.0.* ..." because AFAIU PyPI classifiers are
    not fine-grained enough
  Keeping all these lists consistent is a pain.
  **The solution**: ``check-python-versions`` will compare these lists and warn
  you if they don't match ::
      $ check-python-versions ~/projects/*
      /home/mg/projects/check-manifest:
      setup.py says:              2.7, 3.6, 3.7, 3.8, 3.9, PyPy
      - python_requires says:     2.7, 3.6, 3.7, 3.8, 3.9
      tox.ini says:               2.7, 3.6, 3.7, 3.8, 3.9, PyPy, PyPy3
      .travis.yml says:           2.7, 3.6, 3.7, 3.8, 3.9, PyPy, PyPy3
      appveyor.yml says:          2.7, 3.6, 3.7, 3.8, 3.9
      /home/mg/projects/dozer:
      setup.py says:              2.7, 3.6, 3.7, 3.8, 3.9
      tox.ini says:               2.7, 3.6, 3.7, 3.8, 3.9
      .travis.yml says:           2.7, 3.6, 3.7, 3.8, 3.9
      appveyor.yml says:          2.7, 3.6, 3.7, 3.8, 3.9
      /home/mg/projects/eazysvn:
      setup.py says:              2.7, 3.6, 3.7, 3.8, 3.9, PyPy
      tox.ini says:               2.7, 3.6, 3.7, 3.8, 3.9, PyPy, PyPy3
      .travis.yml says:           2.7, 3.6, 3.7, 3.8, 3.9, PyPy, PyPy3
      appveyor.yml says:          2.7, 3.6, 3.7, 3.8, 3.9
      all ok!


pkgId: 52e819c0c67fcff3da149e82eea07618a39db9f4eacf378111b55182b7d21337
name: python-check-requirements-txt
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Check the missing packages in requirements.txt
url: https://pypi.org/project/check-requirements-txt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-requirements-txt-1.2.3-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#Installation)
  - [License](#License)

  First install this package into current python env
  ```console
  pip install check-requirements-txt
  ```
  Then set up `pre-commit` hooks
  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  > NOTE:
  >
  > Due to the pre-commit isolated pyenv runtime, this package can't be act as a normal git repo pre-commit hooks.
  >
  > If the project's requirements.txt does not match pattern `*requirement*.txt`, you'll need to specify it.
  ```yaml
  default_stages: [commit]
  repos:
    - repo: local
      hooks:
        - id: check-requirements-txt
          name: check-requirements-txt
          description: Check the missing packages in requirements.txt.
          entry: check-requirements-txt
          args: ['--dst_dir', '.', '--ignore', 'pip,whatever,modules,you,want,to,ignore,with,comma,separated']
          language: python
          types: [python]
  ```
  `check-requirements-txt` can be used as a normal cli tool, see `check-requirements-txt --help` for more details.

  ```shell
  Bad import detected: "bs4"
  /Users/ferstar/PycharmProjects/xxx_demo/xxx_spider.py:12
  Bad import detected: "requests"
  /Users/ferstar/PycharmProjects/xxx_demo/xxx_handler.py:17
  "numpy" required by: {'numpy', 'scikit-learn', 'tensorflow', 'pandas'}

  ~ echo $?
  ~ 2
  ```

  `check-requirements-txt` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 9ec07d0543a67d506a95c00d21f21eadd1551545b63fbdb4829b575ddfe24013
name: python-check-shapes
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A library for annotating and checking the shapes of tensors.
url: https://gpflow.github.io/check_shapes
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-shapes-1.1.1-1.src.rpm
checksum_type: sha256
description:
  `check_shapes` is a library for annotating and checking tensor shapes.
  For example:

  ```python
  import tensorflow as tf

  from gpflow.experimental.check_shapes import check_shapes

  @tf.function
  @check_shapes(
      "features: [batch..., n_features]",
      "weights: [n_features]",
      "return: [batch...]",
  )
  def linear_model(features: tf.Tensor, weights: tf.Tensor) -> tf.Tensor:
      return tf.einsum("...i,i -> ...", features, weights)
  ```

  For more information see our [documentation](https://gpflow.github.io/check_shapes).



  The recommended way to install `check_shapes` is from pypi:

  ```bash
  pip install check_shapes
  ```



  To develop `check_shapes`, check it out from GitHub:

  ```bash
  git clone git@github.com:GPflow/check_shapes.git
  ```

  We use [Poetry](https://python-poetry.org/) to install and manage dependencies. Follow their
  instructions for how to install Poetry itself. Then:

  ```bash
  cd check_shapes
  poetry install
  ```

  To check you installation run our tests:

  ```bash
  poetry run task test
  ```

  For testing with different versions of Python and dependencies, see the `poetryenv` script.


pkgId: 496803375977128bc2f9d63dc8102f6bfeb08153ca420c9e8e64a48b5fbd4856
name: python-check-soa-serials
arch: src
version: 0.3.0
epoch: 0
release: 1
url: https://pypi.org/project/check-soa-serials/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-soa-serials-0.3.0-1.src.rpm
checksum_type: sha256
summary:
  check_soa_serials is an Icinga2/Nagios plugin which compares the SOA serial numbers for the same DNS zone(s) from two different servers to ensure they are in sync

description:
  check_soa_serials is a [Nagios]/[Icinga2] plugin that compares the SOA serial numbers for the same DNS zone(s) from two different servers to ensure they are in sync
  Requires Python 3.6+

  You can install with [pip]:
  ```sh
  python3 -m pip install check_soa_serials
  ```
  Or install from source:
  ```sh
  git clone <url>
  pip install check_soa_serials
  ```

  ```sh
  usage: check_soa_serials [-h] [--proto {tcp,udp}] [--zones-file zones_file] [--critical CRITICAL] [--warning WARNING] [--zone ZONES_FROM_ARGS] [--verbose] host host
  ```
  The simplest case:
  ```sh

  both `dnsserver1.domain.tld` and `dnsserver2.domain.tld.

  check_soa_serials --zone myzone.domain.tld dnsserver1.domain.tld dnsserver2.domain.tld
  ```
  The same as the preceding example, but WARNING instead of CRITICAL by altering the critical threshold to be impossible to match:
  ```sh
  check_soa_serials --zone myzone.domain.tld --critical=~: dnsserver1.domain.tld dnsserver2.domain.tld
  ```
  Allow some leeway for the SOA serials to be a value of `99` apart before alerting:
  ```sh
  check_soa_serials --zone myzone.domain.tld --critical=99 --warning=99 dnsserver1.domain.tld dnsserver2.domain.tld
  ```
  For more on Nagios plugin ranges, thresholds, perfdata, and return codes, see [Nagios Plugin Development Guidelines].

  When setting the `--warning` and `--critical` flags, you should know how your DNS servers increase their SOA serial values when setting warning or critical ranges.
  The DNS standards require only ([RFC 1982]) that a server increase the value by a reasonable interval that avoids wrapping around in a way that would confuse secondary servers. The rest is up to the implementation to decide.
  Most(?) implementations follow the recommendation of [RFC 1912] and use what amounts to a timestamp and revision field:
  `YYYYMMDDnn (YYYY=year, MM=month, DD=day, nn=revision number)`.
  With a reasonable implementation (e.g. [bind]), the default threshold values (any nonzero value will alert) could be fine in a quiet environment.
  In a busy DNS environment with constantly-updating zones you might need to set the values higher to avoid getting alerts about every single zone transfer before it completes.

  Here is an Icinga2 `CheckCommand` object for this plugin:
  ```
  object CheckCommand "soa_serials" {
    command = [ PluginDir + "/check_soa_serials", ]
    arguments = {
      "--critical" = {
        description = "Critical range for number of zones not in sync"
        key = "--critical"
        value = "$soa_serials_critical$"
      }
      "--proto" = {
        description = "Protocol to use for DNS queries"
        key = "--proto"
        value = "$soa_serials_proto$"
      }
      "--warning" = {
        description = "Warning range for number of zones not in sync"
        key = "--warning"
        value = "$soa_serials_warning$"
      }
      "--zone" = {
        description = "A zone to compare the serials for between DNS hosts"
        key = "--zone"
        repeat_key = true
        value = "$soa_serials_zone$"
      }
      "--zones-file" = {
        description = "Protocol to use for DNS queries"
        key = "--zones-file"
        value = "$soa_serials_zones_file$"
      }
      secondary = {
        description = "DNS host to check"
        required = true
        skip_key = true
        value = "$soa_serials_secondary$"
      }
      primary = {
        description = "DNS host to check against"
        required = true
        skip_key = true
        value = "$soa_serials_primary$"
      }
    }
    vars.soa_serials_secondary = "$address$"
  }
  ```
  And a minimal example Icinga Service:
  ```
  object Service "host.domain.tld_check_soa" {
    import "generic-service"
    display_name = "DNS Zone SOA serials in sync"
    host_name = "host.domain.tld"
    check_command = "soa_serials"
    notes = "`check_soa_serials` is a custom plugin which compares the SOA serial numbers for the same DNS zone from two different servers to ensure they are in sync"
    notes_url = "https://github.com/theias/check_soa_serials"
    vars.soa_serials_primary = "primarydns.domain.tld"
    vars.zone = "_dnszone.domain.tld"
  }
  ```
  Note on the command path: the above Icinga2 configuration object points to the command in Icinga2's configured `PluginDir`, but this can be configured however you like. For instance:
  * point it to wherever it is installed by its full path
  * symlink from the specified path to the actual script.
  Up to you!

  DNSSEC is not supported, but it could be.
  Run-time could be decreased by running multiple checks concurrently. My use case did not call for this, but I'm open to the idea.

  Merge requests are welcome. For major changes, open an issue first to discuss what you want to change.
  To run the test suite:
  ```bash

  make
  ```
  Please make sure to update tests along with any changes.

  License :: OSI Approved :: MIT License
  [Icinga2]: https://en.wikipedia.org/wiki/Icinga
  [Nagios Plugin Development Guidelines]: https://nagios-plugins.org/doc/guidelines.html
  [Nagios]: https://en.wikipedia.org/wiki/Nagios
  [RFC 1912]: https://datatracker.ietf.org/doc/html/rfc1912
  [RFC 1982]: https://datatracker.ietf.org/doc/html/rfc1982
  [bind]: https://en.wikipedia.org/wiki/BIND
  [pip]: https://pip.pypa.io/en/stable/


