# packages

pkgId: 7dae98a4b697e1c13dd9542cb5d38b2ffa2265d1cde7636c40d7479a4ebca6a7
name: python-adabmDCA-help
arch: noarch
version: 0.2.7
epoch: 0
release: 1
summary: Development documents and examples for adabmDCA
url: https://github.com/spqb/adabmDCA
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adabmDCA-0.2.7-1.src.rpm
location_href: Packages/python-adabmDCA-help-0.2.7-1.noarch.rpm
checksum_type: sha256
description:
  **Authors:**
  - **Lorenzo Rosset** (Sorbonne Université, Sapienza Università di Roma)
  - **Roberto Netti** (Sorbonne Université)
  - **Anna Paola Muntoni** (Politecnico di Torino)
  - **Martin Weigt** (Sorbonne Université)
  - **Francesco Zamponi** (Sapienza Università di Roma)

  **Maintainer:** Lorenzo Rosset



  **adabmDCA 2.0** is a flexible yet easy-to-use implementation of Direct Coupling Analysis (DCA) based on Boltzmann machine learning. This package provides tools for analyzing residue-residue contacts, predicting mutational effects, scoring sequence libraries, and generating artificial sequences, applicable to both protein and RNA families. The package is designed for flexibility and performance, supporting multiple programming languages (C++, Julia, Python) and architectures (single-core/multi-core CPUs and GPUs).
  This repository contains the Python GPU version of adabmDCA, maintained by **Lorenzo Rosset**.

  The project's main repository can be found at [adabmDCA 2.0](https://github.com/spqb/adabmDCA.git).



  - **Direct Coupling Analysis (DCA)** based on Boltzmann machine learning.
  - Support for **dense** and **sparse** generative DCA models.
  - Available on multiple architectures: single-core and multi-core CPUs, GPUs.
  - Ready-to-use for **residue-residue contact prediction**, **mutational-effect prediction**, and **sequence design**.
  - Compatible with protein and RNA family analysis.




  Open a terminal and run
  ```bash
  pip install adabmDCA
  ```


  Clone the repository locally and then install the requirements and the package. In a terminal, run:

  ```bash
  git clone git@github.com:spqb/adabmDCApy.git
  cd adabmDCApy
  pip install .
  ```



  After installation, all the main routines can be launched though the script `adabmDCA.sh` or directly form the terminal using the command `adabmDCA`.

  To get started with adabmDCA in Python, please refer to the [Documentation](https://spqb.github.io/adabmDCApy/) or the [Colab notebook](https://colab.research.google.com/drive/1l5e1W8pk4cB92JAlBElLzpkEk6Hdjk7B?usp=sharing).



  This package is open-sourced under the MIT License.



  If you use this package in your research, please cite:

  > Rosset, L., Netti, R., Muntoni, A.P., Weigt, M., & Zamponi, F. (2024). adabmDCA 2.0: A flexible but easy-to-use package for Direct Coupling Analysis.



  This work was developed in collaboration with Sorbonne Université, Sapienza Università di Roma, and Politecnico di Torino.


pkgId: d45df4739de6faf56e6d5afcb49982f76cbf27b76efa00ff97a909bba9e82d1d
name: python-adalib-help
arch: noarch
version: 8.0.0
epoch: 0
release: 1
summary: Development documents and examples for adalib
url: https://adamatics.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adalib-8.0.0-1.src.rpm
location_href: Packages/python-adalib-help-8.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains the source code of `adalib`, the Python library to interact with the AdaLab platform.



  `adalib` can be installed from PyPI or a `devpi` index:

  ```sh

  pip install adalib

  pip install --extra-index-url <devpi_index_url> adalib
  ```

  In order to add it to the dependencies of a Python project using `poetry` use:

  ```sh
  poetry source add --priority=supplemental <repo_name> <devpi_index_url>
  poetry source add --priority=primary PyPI
  poetry add --source <repo_name> adalib
  ```



  See the [package documentation](https://adamatics-adalib.readthedocs-hosted.com/en/latest/), as well as the [example Notebooks](https://github.com/adamatics/adalib_example_notebooks).



  See the [contributor's guide](CONTRIBUTING.md).


pkgId: f7d25296569232c6520a4f749279d85e949ab8ffdc93f2e6353f9c53f231e9b2
name: python-adapta-help
arch: noarch
version: 3.3.0
epoch: 0
release: 1
summary: Development documents and examples for adapta
url: https://github.com/SneaksAndData/adapta
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adapta-3.3.0-1.src.rpm
location_href: Packages/python-adapta-help-3.3.0-1.noarch.rpm
checksum_type: sha256
description:
  This project aim at providing tools needed for everyday activities of data scientists and engineers:
  - Connectors for various cloud APIs
  - Secure secret handlers for various remote storages
  - Logging framework
  - Metrics reporting framework
  - Storage drivers for various clouds and storage types



  This module provides basic Delta Lake operations without Spark session, based on [delta-rs](https://github.com/delta-io/delta-rs) project.

  Please refer to the [module](adapta/storage/delta_lake/v3/README.md) documentation for examples.



  Please refer to the [module](adapta/storage/secrets/README.md) documentation for examples.



  Please refer to the [module](adapta/storage/distributed_object_store/v3/datastax_astra/README.md) documentation for examples.


pkgId: a4b596f6ed96ba99ecfc4d43387801ade819e0a5a75f362c8027a9b146b3e6de
name: python-adaptive-cards-py-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for adaptive-cards-py
url: https://github.com/dennis6p/adaptive-cards-py
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adaptive-cards-py-0.2.2-1.src.rpm
location_href: Packages/python-adaptive-cards-py-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  - [About](#about)
  - [Features](#features)
  - [Dependencies](#dependencies)
  - [Installation](#installation)
  - [Library structure](#library-structure)
  - [Usage](#usage)
    - [A simple card](#a-simple-card)
    - [Adding multiple elements at once](#adding-multiple-elements-at-once)
    - [A more complex card](#a-more-complex-card)
    - [Validate schema](#validate-schema)
    - [Send card to MS Teams](#send-card-to-ms-teams)
  - [Examples](#examples)
  - [Feature Roadmap](#feature-roadmap)
  - [Contribution](#contribution)

  [![PyPI version](https://badge.fury.io/py/adaptive-cards-py.svg)](https://pypi.org/project/adaptive-cards-py/)

  A thin Python wrapper for creating [**Adaptive Cards**](https://adaptivecards.io/) easily on code level. The deep integration of Python's `typing` package prevents you from creating invalid schemas and guides you while setting up the code for generating visual appealing cards.

  If you are interested in the general concepts of adaptive cards and want to dig a bit deeper, have a look into the [**official documentation**](https://learn.microsoft.com/en-us/adaptive-cards/) or get used to the [**schema**](https://adaptivecards.io/explorer/) first.

  💡 **Please note**
  <br>This library is work in progress. Missing parts are planned to be added from time to time.



  This library is intended to provide a clear and simple interface for creating adaptive cards with only a few lines of code in a more robust way. The heavy usage of Python's `typing` library should prevent one from creating invalid schemes and structures. Instead, creating and sending cards should be intuitive and be supported by the typing system.

  For a comprehensive introduction into the main ideas and patterns of adaptive cards, head over to the [**official documentation**](https://docs.microsoft.com/en-us/adaptive-cards). I also recommend using the [**schema explorer**](https://adaptivecards.io/explorer) page alongside the implementation, since the library's type system relies on these schemas.

  Further resources can be found here:

  * [__Format cards in Teams__](https://learn.microsoft.com/en-us/microsoftteams/platform/task-modules-and-cards/cards/cards-format?tabs=adaptive-md%2Cdesktop%2Cdesktop1%2Cdesktop2%2Cconnector-html)
  * [__Official repository__](https://github.com/microsoft/AdaptiveCards)

  💡 **Please note**
  <br> There are size limitations related to the [__target framework__](https://learn.microsoft.com/en-us/adaptive-cards/resources/partners#live) (or "__Host__") a card is supposed to be used with. As of now, the maximum card size can be __28KB__ when used with Webhooks in Teams ([__Format cards in Teams__](https://learn.microsoft.com/en-us/microsoftteams/platform/task-modules-and-cards/cards/cards-format?tabs=adaptive-md%2Cdesktop%2Cdesktop1%2Cdesktop2%2Cconnector-html)). For bot frameworks the upper limit is set to __40KB__ ([__Format your bot messages__](https://learn.microsoft.com/en-us/microsoftteams/platform/bots/how-to/format-your-bot-messages)). An corresponding check is planned to be added soon to the [`SchemaValidator`](#validate-schema).



  💡 **Please note**
  <br>It's highly recommended to turn on the **type check** capabilities for Python in your editor. This will serve you with direct feedback about the structures you create. If you are trying to assign values of incompatible types, your editor will mark it as such and yell at you right in the moment you are about to do so. Otherwise, invalid schemas can be detected by making use of the card validation,
  once the card has been successfully created.

  + Type annotated components based on Python's **dataclasses**
  + Schema validation for version compatibility
  + Simple `JSON` export
  + Compliant with the official structures and ideas
  + Send cards to MS Teams via `TeamsClient`



  * Python 3.10+
  * `dataclasses-json`
  * `requests`



  ```bash
  pip install adaptive-cards-py
  ```



  **Adaptive cards** can consist of different kinds of components. The four main categories beside the actual cards are **Elements**, **Containers**, **Actions** and **Inputs**. You can find all available components for each category within the corresponding module. The `AdaptiveCard` is defined in the `cards` module.

  In addition to that, some fields of certain components are of custom types. These types are living inside the `card_types` mpdule. For instance, if you are about to assign a color to a `TextBlock`, the field `color` will only accept a value of type `Colors`, which is implemented in the aforementioned Python file.

  To perform validation on a fully initialized card, one can make use of the `CardValidator` class (`validation` module). Similar to the whole library, this class provides a simple interface. For creating a validator, a Factory (`CardValidatorFactory`) can be used, in order to account for the desired target framework. Validation will check the following points:


  * Are any components used, which are not yet available for the card version?
  * Is the card size within the limitation defined by the target framework?
  * Does the schema correspond to the official card schema?
  * Are there any components in the card body at all?





  A simple `TextBlock` lives in the `elements` module and can be used after it's import.

  ```Python
  from adaptive_cards.elements import TextBlock

  text_block: TextBlock = TextBlock(text="It's your first card")
  ```
  For this component, `text` is the only required property. However, if more customization is needed, further available fields can be used.

  ```Python
  from adaptive_cards.elements import TextBlock
  import adaptive_cards.card_types as types

  text_block: TextBlock = TextBlock(
      text="It's your second card",
      color=types.Colors.ACCENT,
      size=types.FontSize.EXTRA_LARGE,
      horizontal_alignment=types.HorizontalAlignment.CENTER,
  )
  ```

  An actual card with only this component can be created like this.

  ```Python
  from adaptive_cards.card import AdaptiveCard

  ...

  version: str = "1.4"
  card: AdaptiveCard = AdaptiveCard.new() \
                                   .version(version) \
                                   .add_item(text_block) \
                                   .create()
  ```

  Find your final layout below.

  ![simple card](https://github.com/dennis6p/adaptive-cards-py/blob/main/examples/simple_card/simple_card.jpg?raw=true)

  💡 **Please note**
  <br>After building the object is done, the `create(...)` method must be called in order to create the final object. In this case, the object will be of type `AdaptiveCard`.

  To directly export your result, make use of the
  `to_json()` method provided by every card.

  ```Python
  with open("path/to/out/file.json", "w+") as f:
      f.write(card.to_json())

  ```



  Assuming you have a bunch of elements you want your card to enrich with. There is also a method for doing so. Let's re-use the example from before, but add another `Image` element here as well.

  ```Python
  from adaptive_cards.elements import TextBlock, Image
  import adaptive_cards.card_types as types

  text_block: TextBlock = TextBlock(
      text="It's your third card",
      color=types.Colors.ACCENT,
      size=types.FontSize.EXTRA_LARGE,
      horizontal_alignment=types.HorizontalAlignment.CENTER,
  )

  image: Image = Image(url="https://adaptivecards.io/content/bf-logo.png")

  version: str = "1.4"
  card: AdaptiveCard = AdaptiveCard.new() \
                                   .version(version) \
                                   .add_items([text_block, image]) \
                                   .create()









  with open("path/to/out/file.json", "w+") as f:
      f.write(card.to_json())
  ```

  This will result in a card like shown below.

  ![simple card 2](https://github.com/dennis6p/adaptive-cards-py/blob/main/examples/simple_card/simple_card_2.jpg?raw=true)



  You can have a look on the following example for getting an idea of what's actually possible with adaptive cards.

  ![wrap up card](https://github.com/dennis6p/adaptive-cards-py/blob/main/examples/wrap_up_card/wrap_up_card.jpg?raw=true)

  <details>
  <summary>Code</summary>

  ```python
  import adaptive_cards.card_types as types
  from adaptive_cards.actions import ActionToggleVisibility, TargetElement
  from adaptive_cards.validation import SchemaValidator, Result
  from adaptive_cards.card import AdaptiveCard
  from adaptive_cards.elements import TextBlock, Image
  from adaptive_cards.containers import Container, ContainerTypes, ColumnSet, Column

  containers: list[ContainerTypes] = []

  icon_source: str = "https://icons8.com/icon/vNXFqyQtOSbb/launch"
  icon_url: str = "https://img.icons8.com/3d-fluency/94/launched-rocket.png"

  header_column_set: ColumnSet = ColumnSet(
      columns=[
          Column(
              items=[
                  TextBlock(text="Your Daily Wrap-Up", size=types.FontSize.EXTRA_LARGE)
              ],
              width="stretch",
          ),
          Column(items=[Image(url=icon_url, width="40px")], rtl=True, width="auto"),
      ]
  )
  containers.append(
      Container(
          items=[header_column_set], style=types.ContainerStyle.EMPHASIS, bleed=True
      )
  )

  containers.append(
      Container(
          items=[
              TextBlock(
                  text="**Some numbers for you**",
                  size=types.FontSize.MEDIUM,
              ),
              ColumnSet(
                  columns=[
                      Column(
                          items=[
                              TextBlock(text="_Total_"),
                              TextBlock(text="_Done by you_"),
                              TextBlock(text="_Done by other teams_"),
                              TextBlock(text="_Still open_"),
                              TextBlock(text="_Closed_"),
                          ]
                      ),
                      Column(
                          items=[
                              TextBlock(text="5"),
                              TextBlock(text="4"),
                              TextBlock(text="3"),
                              TextBlock(text="6"),
                              TextBlock(text="1"),
                          ],
                          spacing=types.Spacing.MEDIUM,
                          rtl=True,
                      ),
                  ],
                  separator=True,
              ),
          ],
          spacing=types.Spacing.MEDIUM,
      )
  )

  containers.append(
      Container(
          items=[
              TextBlock(
                  text="**Detailed Results**",
                  size=types.FontSize.MEDIUM,
              ),
          ],
          separator=True,
          spacing=types.Spacing.EXTRA_LARGE,
      )
  )

  sample_column_set: ColumnSet = ColumnSet(
      columns=[
          Column(items=[TextBlock(text="12312")]),
          Column(items=[TextBlock(text="done", color=types.Colors.GOOD)]),
          Column(items=[TextBlock(text="abc")]),
          Column(
              items=[
                  Image(
                      url="https://adaptivecards.io/content/down.png",
                      width="20px",
                      horizontal_alignment=types.HorizontalAlignment.RIGHT,
                  )
              ],
              select_action=ActionToggleVisibility(
                  title="More",
                  target_elements=[
                      TargetElement(
                          element_id="toggle-me",
                      )
                  ],
              ),
          ),
      ]
  )

  containers.append(
      Container(
          items=[
              Container(
                  items=[
                      ColumnSet(
                          columns=[
                              Column(items=[TextBlock(text="**Number**")]),
                              Column(items=[TextBlock(text="**Status**")]),
                              Column(items=[TextBlock(text="**Topic**")]),
                              Column(items=[TextBlock(text="")]),
                          ],
                          id="headline",
                      ),
                  ],
                  style=types.ContainerStyle.EMPHASIS,
                  bleed=True,
              ),
              Container(items=[sample_column_set]),
              Container(
                  items=[
                      TextBlock(
                          text="_Here you gonna find more information about the whole topic_",
                          id="toggle-me",
                          is_visible=False,
                          is_subtle=True,
                          wrap=True,
                      )
                  ]
              ),
          ],
      )
  )

  containers.append(
      Container(
          items=[
              TextBlock(
                  text=f"Icon used from: {icon_source}",
                  size=types.FontSize.SMALL,
                  horizontal_alignment=types.HorizontalAlignment.CENTER,
                  is_subtle=True,
              )
          ]
      )
  )

  card = AdaptiveCard.new().version("1.5").add_items(containers).create()

  validator: SchemaValidator = SchemaValidator()
  result: Result = validator.validate(card)

  print(f"Validation was successful: {result == Result.SUCCESS}")

  ```

  </details>

  <details>
  <summary>Schema</summary>

  ```json
  {
      "type": "AdaptiveCard",
      "version": "1.5",
      "schema": "http://adaptivecards.io/schemas/adaptive-card.json",
      "body": [
          {
              "items": [
                  {
                      "type": "ColumnSet",
                      "columns": [
                          {
                              "items": [
                                  {
                                      "text": "Your Daily Wrap-Up",
                                      "type": "TextBlock",
                                      "size": "extraLarge"
                                  }
                              ],
                              "width": "stretch"
                          },
                          {
                              "items": [
                                  {
                                      "url": "https://img.icons8.com/3d-fluency/94/launched-rocket.png",
                                      "type": "Image",
                                      "width": "40px"
                                  }
                              ],
                              "rtl": true,
                              "width": "auto"
                          }
                      ]
                  }
              ],
              "type": "Container",
              "style": "emphasis",
              "bleed": true
          },
          {
              "spacing": "medium",
              "items": [
                  {
                      "text": "**Some numbers for you**",
                      "type": "TextBlock",
                      "size": "medium"
                  },
                  {
                      "separator": true,
                      "type": "ColumnSet",
                      "columns": [
                          {
                              "items": [
                                  {
                                      "text": "_Total_",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "_Done by you_",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "_Done by other teams_",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "_Still open_",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "_Closed_",
                                      "type": "TextBlock"
                                  }
                              ]
                          },
                          {
                              "spacing": "medium",
                              "items": [
                                  {
                                      "text": "5",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "4",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "3",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "6",
                                      "type": "TextBlock"
                                  },
                                  {
                                      "text": "1",
                                      "type": "TextBlock"
                                  }
                              ],
                              "rtl": true
                          }
                      ]
                  }
              ],
              "type": "Container"
          },
          {
              "separator": true,
              "spacing": "extraLarge",
              "items": [
                  {
                      "text": "**Detailed Results**",
                      "type": "TextBlock",
                      "size": "medium"
                  }
              ],
              "type": "Container"
          },
          {
              "items": [
                  {
                      "items": [
                          {
                              "id": "headline",
                              "type": "ColumnSet",
                              "columns": [
                                  {
                                      "items": [
                                          {
                                              "text": "**Number**",
                                              "type": "TextBlock"
                                          }
                                      ]
                                  },
                                  {
                                      "items": [
                                          {
                                              "text": "**Status**",
                                              "type": "TextBlock"
                                          }
                                      ]
                                  },
                                  {
                                      "items": [
                                          {
                                              "text": "**Topic**",
                                              "type": "TextBlock"
                                          }
                                      ]
                                  },
                                  {
                                      "items": [
                                          {
                                              "text": "",
                                              "type": "TextBlock"
                                          }
                                      ]
                                  }
                              ]
                          }
                      ],
                      "type": "Container",
                      "style": "emphasis",
                      "bleed": true
                  },
                  {
                      "items": [
                          {
                              "type": "ColumnSet",
                              "columns": [
                                  {
                                      "items": [
                                          {
                                              "text": "12312",
                                              "type": "TextBlock"
                                          }
                                      ]
                                  },
                                  {
                                      "items": [
                                          {
                                              "text": "done",
                                              "type": "TextBlock",
                                              "color": "good"
                                          }
                                      ]
                                  },
                                  {
                                      "items": [
                                          {
                                              "text": "abc",
                                              "type": "TextBlock"
                                          }
                                      ]
                                  },
                                  {
                                      "items": [
                                          {
                                              "url": "https://adaptivecards.io/content/down.png",
                                              "type": "Image",
                                              "horizontalAlignment": "right",
                                              "width": "20px"
                                          }
                                      ],
                                      "selectAction": {
                                          "title": "More",
                                          "targetElements": [
                                              {
                                                  "elementId": "toggle-me"
                                              }
                                          ],
                                          "type": "Action.ToggleVisibility"
                                      }
                                  }
                              ]
                          }
                      ],
                      "type": "Container"
                  },
                  {
                      "items": [
                          {
                              "id": "toggle-me",
                              "isVisible": false,
                              "text": "_Here you gonna find more information about the whole topic_",
                              "type": "TextBlock",
                              "isSubtle": true,
                              "wrap": true
                          }
                      ],
                      "type": "Container"
                  }
              ],
              "type": "Container"
          },
          {
              "items": [
                  {
                      "text": "Icon used from: https://icons8.com/icon/vNXFqyQtOSbb/launch",
                      "type": "TextBlock",
                      "horizontalAlignment": "center",
                      "isSubtle": true,
                      "size": "small"
                  }
              ],
              "type": "Container"
          }
      ]
  }
  ```

  </details>



  New components and fields are getting introduced every now and then. This means, if you are using an early version for a card and add fields, which are not compliant with it, you will have an invalid schema. To prevent you from exporting fields not yet supported by the card and target framework, a card validation can be performed for the expected [__target framework__](https://learn.microsoft.com/en-us/adaptive-cards/resources/partners#live) (see [__Library structure__](#library-structure) for more info). For MS Teams as the target framework, it would like like this:

  ```python
  from adaptive_cards.validator import (
      CardValidatorFactory,
      CardValidator,
      Result,
      Finding
  )

  ...

  version: str = "1.4"
  card: AdaptiveCard = AdaptiveCard.new() \
                                   .version(version) \
                                   .add_items([text_block, image]) \
                                   .create()


  validator: CardValidator = CardValidatorFactory.create_validator_microsoft_teams()
  result: Result = validator.validate(card)

  print(f"Validation was successful: {result == Result.SUCCESS}")




  card_size: float = validator.card_size(card)
  print(card_size)



  details: list[Finding] = validator.details()




  ```



  Of course, you want to create those cards for a reason. So once you did that, you might want to send it to one of the compatible services like MS Teams. See the following example, how this can be done, assuming that all previously mentioned steps are done prior to that:

  ```python

  ...

  from adaptive_cards.clients import TeamsClient
  from requests import Response

  ...


  webhook_url: str = "YOUR-URL"
  client: TeamsClient = TeamsClient(webhook_url)
  response: Response = client.send(card)

  new_webhook_url: str = "YOUR-URL-OF-SECOND-CHANNEL"
  client.set_webhook_url(new_webhook_url)
  response: Response = client.send(card)

  ...

  ```

  So far, there is only a MS Teams client available. If further services should be supported, give me some feedback by opening an Issue for instance.

  Find further information about sending cards or creating Webhooks to/in MS Teams [__here__](https://support.microsoft.com/en-us/office/create-incoming-webhooks-with-workflows-for-microsoft-teams-8ae491c7-0394-4861-ba59-055e33f75498).



  If you are interested in more comprehensive examples or the actual source code, have a look into the `examples` folder.



  * [x] Add size check to schema validation
  * [x] Add proper schema validation
  * [x] Add further target framework validators
  * [ ] Provide more examples
  * [ ] Allow reading of json-like schemas



  Feel free to create issues, fork the repository or even come up with a pull request. I am happy about any kind of contribution and would love
  to hear your feedback!

rpm_license:
  MIT License  Copyright (c) 2023 Dennis Eder  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: d160bb75aa3a289c899355bceb6de4a1ca62edf232bde9c8dc7bf6d7598b6c4a
name: python-adaptive-shots-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for adaptive-shots
url: https://github.com/gokhanmeteerturk/adaptive-shots
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adaptive-shots-0.1.0-1.src.rpm
location_href: Packages/python-adaptive-shots-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ![build status](https://github.com/gokhanmeteerturk/adaptive-shots/actions/workflows/test.yml/badge.svg?branch=main)
  ![Python](https://img.shields.io/pypi/pyversions/adaptive-shots.svg)
  [![codecov](https://codecov.io/github/gokhanmeteerturk/adaptive-shots/branch/main/graph/badge.svg?token=375FXNSAFH)](https://codecov.io/github/gokhanmeteerturk/adaptive-shots) ![PyPI](https://img.shields.io/pypi/v/adaptive-shots) ![License](https://img.shields.io/pypi/l/adaptive-shots) ![Downloads](https://img.shields.io/pypi/dm/adaptive-shots)

  <p align="center">  gokhanmeteerturk/adaptive-shots </p>
  <p align="center">  <a href="https://github.com/gokhanmeteerturk/adaptive-shots">Github Repo</a> | Documentation (in progress) </p>



  Adaptive Shots is a Python package that turns your prompts into <ins>few-shots prompts</ins> on the fly.

  It automatically selects the most relevant prompt&answer pairs from the database based on what worked well before. Adaptive-shots package uses [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning) algorithm [UCB1-Tuned](https://homes.di.unimi.it/~cesabian/Pubblicazioni/ml-02.pdf) and learns from user feedback to improve its selections over time by using the numerical feedback as a reward.

  This package implements UCB1-Tuned, but with a contextual cosine similarity of prompts to dynamically select and rank the most relevant and well performing old prompts for a given prompt text.

  Initially designed for my Intelligent Tutoring System (ITS) project, the package is generalizable for any scenario requiring adaptive, reinforcement-learning-based prompt management.



  - **Sentence transformers** for generating vector representations.
    Defaults to `all-MiniLM-L6-v2` (384 dimensional dense vector space) but can be configured easily.
  - **SQLite Vector Search** with [sqlite-vec](https://github.com/asg017/sqlite-vec). (Cosine distance is used)
  - **Exploration vs Exploitation**.


  <p align="center">
  <img src="https://github.com/user-attachments/assets/20688df7-b89f-471a-8562-35fa29b10db5"/>
  </p>


  ```bash
  pip install adaptive-shots
  ```



  Core feature, few-shots prompt generation, looks like this:
  ```python
  shot_list = db.get_best_shots(
    prompt='Who is the author of Twelfth Night?',
    domain='geography',limit=2
  )
  ```
  You can then use the returned list for message generation:
  ```python
  shot_list.to_messages()
  ```
  ```js
  // Output:
  [
    {"role": "user", "content": "Who wrote Hamlet?"},
    {"role": "assistant", "content": "William Shakespeare"},
    {"role": "user", "content": "Who wrote Oedipus Rex?"},
    {"role": "assistant", "content": "Sophocles"}
  ]
  ```



  ```python
  from adaptive_shots import initialize_adaptive_shot_db
  from openai import OpenAI


  db = initialize_adaptive_shot_db('./shots.db')
  client = OpenAI()


  db.register_prompt(
      prompt='What is the capital of France?',
      answer='Paris',
      rating=9.5,
      domain='geography'
  )


  user_query = 'What is the capital of Germany?'
  few_shots_prompt, shot_list = db.create_few_shots_prompt(
      prompt=user_query,
      domain='geography',
      limit=1
  )

  print(few_shots_prompt)

  """
  Prompt: What is the capital of France?
  Answer: Paris

  Prompt: What is the capital of Germany?
  Answer:
  """


  response = client.chat.completions.create(
      model='gpt-4',
      messages=[
        *shot_list.to_messages(),
        {"role": "user", "content": user_query},
      ]
  )
  answer = response.choices[0].message.content


  db.register_prompt(
      prompt=user_query,
      answer=answer,
      rating=9.0, # ideally you should receive this from the user
      domain='geography',
      used_shots=shot_list
  )
  ```






  Registers a new prompt-answer pair and updates the ratings of used shots.


  Generates a few-shot prompt using the best-performing relevant examples.


  Generates a one-shot prompt using the single best-matching example.


  Retrieves the optimal set of shots using the UCB algorithm.



  This work is licensed under the GNU 3 - see the LICENSE file for details.



  If you use this package in your research, please cite:

  ```bibtex
  @software{erturk2024adaptive,
    author       = {Ertürk, Gökhan Mete},
    title        = {Adaptive-Shots: A Contextual Combinatorial Bandit Approach to Few-Shot Prompt Selection},
    year         = {2024},
    url          = {https://github.com/gokhanmeteerturk/adaptive-shots}
  }
  ```


pkgId: fc0645080c7baad74b6df522d8dafb29f038cdf2a474ad8e3c510fa4b00a7b7b
name: python-adaptix-help
arch: noarch
version: 3.0.0b9
epoch: 0
release: 1
summary: Development documents and examples for adaptix
url: https://github.com/reagento/adaptix
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adaptix-3.0.0b9-1.src.rpm
location_href: Packages/python-adaptix-help-3.0.0b9-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://github.com/reagento/adaptix/blob/v3.0.0b6/docs/logo/adaptix-with-title-dark.png?raw=true">
      <source media="(prefers-color-scheme: light)" srcset="https://github.com/reagento/adaptix/blob/v3.0.0b6/docs/logo/adaptix-with-title-light.png?raw=true">
      <img alt="adaptix logo" src="https://raw.githubusercontent.com/reagento/adaptix/v3.0.0b2/docs/logo/adaptix-with-title-light.png?raw=true">
    </picture>

    <hr>

    [![PyPI version](https://img.shields.io/pypi/v/adaptix.svg?color=blue)](https://pypi.org/project/adaptix/)
    [![downloads](https://img.shields.io/pypi/dm/adaptix.svg)](https://pypistats.org/packages/adaptix)
    [![versions](https://img.shields.io/pypi/pyversions/adaptix.svg)](https://github.com/reagento/adaptix)
    [![license](https://img.shields.io/github/license/reagento/dataclass_factory.svg)](https://github.com/reagento/adaptix/blob/master/LICENSE)
  </div>

  An extremely flexible and configurable data model conversion library.

  > [!IMPORTANT]
  > Adaptix is ready for production!
  > The beta version only means there may be some backward incompatible changes, so you need to pin a specific version.

  📚 [Documentation](https://adaptix.readthedocs.io/)



  Install
  ```bash
  pip install adaptix==3.0.0b9
  ```

  Use for model loading and dumping.

  ```python
  from dataclasses import dataclass

  from adaptix import Retort


  @dataclass
  class Book:
      title: str
      price: int


  data = {
      "title": "Fahrenheit 451",
      "price": 100,
  }


  retort = Retort()

  book = retort.load(data, Book)
  assert book == Book(title="Fahrenheit 451", price=100)
  assert retort.dump(book) == data
  ```

  Use for converting one model to another.

  ```python
  from dataclasses import dataclass

  from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column

  from adaptix.conversion import get_converter


  class Base(DeclarativeBase):
      pass


  class Book(Base):
      __tablename__ = 'books'

      id: Mapped[int] = mapped_column(primary_key=True)
      title: Mapped[str]
      price: Mapped[int]


  @dataclass
  class BookDTO:
      id: int
      title: str
      price: int


  convert_book_to_dto = get_converter(Book, BookDTO)

  assert (
      convert_book_to_dto(Book(id=183, title="Fahrenheit 451", price=100))
      ==
      BookDTO(id=183, title="Fahrenheit 451", price=100)
  )
  ```



  * Validation and transformation of received data for your API.
  * Conversion between data models and DTOs.
  * Config loading/dumping via codec that produces/takes dict.
  * Storing JSON in a database and representing it as a model inside the application code.
  * Creating API clients that convert a model to JSON sending to the server.
  * Persisting entities at cache storage.
  * Implementing fast and primitive ORM.



  * Sane defaults for JSON processing, no configuration is needed for simple cases.
  * Separated model definition and rules of conversion
    that allow preserving [SRP](https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html)
    and have different representations for one model.
  * Speed. It is one of the fastest data parsing and serialization libraries.
  * There is no forced model representation, adaptix can adjust to your needs.
  * Support [dozens](https://adaptix.readthedocs.io/en/latest/loading-and-dumping/specific-types-behavior.html) of types,
    including different model kinds:
    ``@dataclass``, ``TypedDict``, ``NamedTuple``,
    [``attrs``](https://www.attrs.org/en/stable/), [``sqlalchemy``](https://docs.sqlalchemy.org/en/20/) and [``pydantic``](https://docs.pydantic.dev/latest/).
  * Working with self-referenced data types (such as linked lists or trees).
  * Saving [path](https://adaptix.readthedocs.io/en/latest/loading-and-dumping/tutorial.html#error-handling)
    where an exception is raised (including unexpected errors).
  * Machine-readable [errors](https://adaptix.readthedocs.io/en/latest/loading-and-dumping/tutorial.html#error-handling)
    that could be dumped.
  * Support for user-defined generic models.
  * Automatic name style conversion (e.g. `snake_case` to `camelCase`).
  * [Predicate system](https://adaptix.readthedocs.io/en/latest/loading-and-dumping/tutorial.html#predicate-system)
    that allows to concisely and precisely override some behavior.
  * Disabling additional checks to speed up data loading from trusted sources.
  * No auto casting by default. The loader does not try to guess value from plenty of input formats.


pkgId: da5f74062df2db1274b48ff3d6d4d61eb2209a0e3400fbbf2cb5a200208ce6b7
name: python-adhoc-api-help
arch: noarch
version: 0.2.9
epoch: 0
release: 1
summary: Development documents and examples for adhoc-api
url: https://pypi.org/project/adhoc-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adhoc-api-0.2.9-1.src.rpm
location_href: Packages/python-adhoc-api-help-0.2.9-1.noarch.rpm
checksum_type: sha256
description:
  An [Archytas](https://github.com/jataware/archytas) tool that uses LLMs to interact with APIs given documentation. User explains what they want in plain english, and then the agent (using the APIs docs for context) writes python code to complete the task.


  ```bash
  pip install adhoc-api
  ```



  This is designed to be paired with an Archytas agent. You may omit the python tool, and the agent should instead return the source code to you rather than running it.

  Here is a complete example of grabbing the HTML content of an API documentation page, converting it to markdown, and then having the adhoc-api tool interact with the API using the generated markdown documentation (see [examples/jokes.py](examples/jokes.py) for reference):

  ```python
  from archytas.react import ReActAgent, FailedTaskError
  from archytas.tools import PythonTool
  from easyrepl import REPL
  from adhoc_api.tool import AdhocApi, APISpec

  from bs4 import BeautifulSoup
  import requests
  from markdownify import markdownify


  def main():
      
      gdc_api: APISpec = {
          'name': "JokesAPI",
          'description': 'JokeAPI is a REST API that serves uniformly and well formatted jokes.',
          'documentation': get_joke_api_documentation(),
      }

      
      adhoc_api = AdhocApi(
          apis=[gdc_api],
          drafter_config={'model': 'gemini-1.5-flash-001'},
          finalizer_config={'model': 'gpt-4o'}
      )
      python = PythonTool()
      agent = ReActAgent(model='gpt-4o', tools=[adhoc_api, python], verbose=True)

      
      for query in REPL(history_file='.chat'):
          try:
              answer = agent.react(query)
              print(answer)
          except FailedTaskError as e:
              print(f"Error: {e}")


  def get_joke_api_documentation() -> str:
      """Download the HTML of the joke API documentation page with soup and convert it to markdown."""
      url = 'https://sv443.net/jokeapi/v2/'
      response = requests.get(url)
      soup = BeautifulSoup(response.text, 'html.parser')
      markdown = markdownify(str(soup))

      return markdown


  if __name__ == "__main__":
      main()
  ```

  Then you can run the script and interact with the agent in the REPL:

  ```
  $ python example.py

  >>> Can you tell me what apis are available?
  The available API is JokesAPI, which is a REST API that serves uniformly and well formatted jokes.

  >>> Can you fetch a safe joke?
  Here is a safe joke from the JokesAPI:

  Category: Pun
  Type: Two-part
  Setup: What kind of doctor is Dr. Pepper?
  Delivery: He's a fizzician.
  ```


pkgId: ce74119feb4ce1eab71eafa38dfd05e71472eff9257d3938115ea3b4fc24b4bf
name: python-adjango-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for adjango
url: https://github.com/Artasov/adjango
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adjango-0.3.1-1.src.rpm
location_href: Packages/python-adjango-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  > Sometimes I use this in different projects, so I decided to put it on pypi

  `ADjango` is a convenient library for simplifying work with Django, which offers various useful managers, services, decorators, utilities for asynchronous programming, a task scheduler for Celery, working with transactions and much more.
  - [Installation](#installation-%EF%B8%8F)
  - [Settings](#settings-%EF%B8%8F)
  - [Overview](#overview)
    - [Manager & Services](#manager--services-%EF%B8%8F)
    - [Utils](#utils-)
    - [Decorators](#decorators-)
    - [Other](#other)


  ```bash
  pip install adjango
  ```



  * ### Add the application to the project.
      ```python
      INSTALLED_APPS = [
          
          'adjango',
      ]
      ```
  * ### In `settings.py` set the params
      ```python
      
      

      
      LOGIN_URL = '/login/'

      
      ADJANGO_BACKENDS_APPS = BASE_DIR / 'apps' # for management commands
      ADJANGO_FRONTEND_APPS = BASE_DIR.parent / 'frontend' / 'src' / 'apps' # for management commands
      ADJANGO_APPS_PREPATH = 'apps.'  # if apps in BASE_DIR/apps/app1,app2...
      ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION = ... # Read about @acontroller, @controller
      ADJANGO_CONTROLLERS_LOGGER_NAME = 'global' # only for usage @a/controller decorators
      ADJANGO_CONTROLLERS_LOGGING = True # only for usage @a/controller decorators
      ADJANGO_EMAIL_LOGGER_NAME = 'email' # for send_emails_task logging
      ```
      ```python
      MIDDLEWARE = [
          ...
          
          'adjango.middleware.IPAddressMiddleware',
          ...
      ]
      ```

  Most functions, if available in asynchronous form, are also available in synchronous form.


  A simple example and everything is immediately clear...
  ```python
  from adjango.fields import AManyToManyField
  from adjango.managers.base import AManager
  from adjango.services.base import ABaseService
  from adjango.models import AModel
  from adjango.polymorphic_models import APolymorphicModel

  class User(AbstractUser, ABaseService):
      objects = AManager()

  class User(AbstractUser, AModel): pass


  class Product(APolymorphicModel):
      
      name = CharField(max_length=100)

  class Order(AModel):
      user = ForeignKey(User, CASCADE)
      products = AManyToManyField(Product)



  products = await Product.objects.aall()
  products = await Product.objects.afilter(name='name')

  order = await Order.objects.agetorn(id=69) # aget or none
  if not order: raise


  await order.products.aset(products)

  await order.products.aset(
    Product.objects.filter(name='name')
  )
  await order.products.aadd(products[0])


  order: Order = await Order.objects.aget(id=69)

  order.user = await order.related('user')
  products = await order.products.aall()

  orders = await Order.objects.prefetch_related('products').aall()
  for o in orders:
      for p in o.products.all():
          print(p.id)

  ```

    `aall`, `afilter`,  `arelated`, и так далее доступны как отдельные функции
    ```python
    from adjango.utils.funcs import aall, agetorn, afilter, aset, aadd, arelated
    ```

  * `aforce_data`

      The `aforce_data` decorator combines data from the `GET`, `POST` and `JSON` body
      request in `request.data`. This makes it easy to access all request data in one place.

  * `atomic`

      An asynchronous decorator that wraps
      function into a transactional context. If an exception occurs, all changes are rolled back.

  * `acontroller/controller`

      An asynchronous decorator that wraps
      function into a transactional context. If an exception occurs, all changes are rolled back.
      ```python
      from adjango.adecorators import acontroller

      @acontroller(name='My View', logger='custom_logger', log_name=True, log_time=True)
      async def my_view(request):
          pass

      @acontroller('One More View')
      async def my_view_one_more(request):
          pass
      ```
      * These decorators automatically catch uncaught exceptions and log if the logger is configured
      `ADJANGO_CONTROLLERS_LOGGER_NAME` `ADJANGO_CONTROLLERS_LOGGING`.
      * You can also implement the interface:
          ```python
          class IHandlerControllerException(ABC):
              @staticmethod
              @abstractmethod
              def handle(fn_name: str, request: WSGIRequest | ASGIRequest, e: Exception, *args, **kwargs) -> None:
                  """
                  An example of an exception handling function.

                  @param fn_name: The name of the function where the exception occurred.
                  @param request: The request object (WSGIRequest or ASGIRequest).
                  @param e: The exception to be handled.
                  @param args: Positional arguments passed to the function.
                  @param kwargs: Named arguments passed to the function.

                  @return: None
                  """
                  pass
          ```
          and use `handle` to get an uncaught exception:
          ```python
          
          from adjango.handlers import HCE # use my example if u need
          ADJANGO_UNCAUGHT_EXCEPTION_HANDLING_FUNCTION = HCE.handle
          ```



  * `AsyncAtomicContextManager`🧘

      An asynchronous context manager for working with transactions, which ensures the atomicity of operations.
      ```python
      from adjango.utils.base import AsyncAtomicContextManager

      async def some_function():
          async with AsyncAtomicContextManager():
              ...
      ```

  * `Tasker`📋

      The Tasker class provides methods for scheduling tasks in `Celery` and `Celery Beat`.
      ```python
      from adjango.utils.tasks import Tasker

      task_id = Tasker.put(
          task=my_celery_task,
          param1='value1',
          param2='value2',
          countdown=60 # The task will be completed in 60 seconds
      )
      ```
      ```python
      from adjango.utils.tasks import Tasker
      from datetime import datetime

      
      Tasker.beat(
          task=my_celery_task,
          name='one_time_task',
          schedule_time=datetime(2024, 10, 10, 14, 30), # Start the task on October 10, 2024 at 14:30
          param1='value1',
          param2='value2'
      )

      
      Tasker.beat(
          task=my_celery_task,
          name='hourly_task',
          interval=3600, # The task runs every hour
          param1='value1',
          param2='value2'
      )
      ```

  * `send_emails`

      Allows you to send emails using templates and context rendering.
      ```python
      from adjango.utils.mail import send_emails

      send_emails(
          subject='Welcome!',
          emails=('user1@example.com', 'user2@example.com'),
          template='emails/welcome.html',
          context={'user': 'John Doe'}
      )
      ```
      ```python
      from adjango.tasks import send_emails_task
      from adjango.utils.tasks import Tasker

      send_emails_task.delay(
          subject='Hello!',
          emails=('user@example.com',),
          template='emails/hello.html',
          context={'message': 'Welcome to our service!'}
      )
      
      Tasker.put(
          task=send_emails_task,
          subject='Hello!',
          emails=('user@example.com',),
          template='emails/hello.html',
          context={'message': 'Welcome to our service!'},
          countdown=60 # The task will be completed in 5 seconds
      )
      ```


pkgId: 6af0d157cabf2d0e7ba8675a6c5043a32315996bbbe4e311838da946f2fbe62b
name: python-adjisan-proxy-scraper-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for adjisan-proxy-scraper
url: https://github.com/adjidev/proxyscraper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adjisan-proxy-scraper-0.1.1-1.src.rpm
location_href: Packages/python-adjisan-proxy-scraper-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  > ===================================

  Let's get started if you don't know about my project


  > 1. python 3.8 or later
  > 2. python installed on you device
  > 3. Code editor or notepad etc


  - install python if python is not installed [click here](https://www.python.org/ftp/python/3.13.1/python-3.13.1-amd64.exe)
  - install my pypi packages
    ```powershell
    python -m pip install adjisan-proxy-scraper
    ```


  - install python if not installed
    ```bash
    sudo apt install python
    ```
  - install my pypi package
    ```bash
    pip install adjisan-proxy-scraper
    ```


  - install python if not installed
    ```bash
    sudo pacman -S python
    ```
  - install my pypi packages
    ```bash
    pip install adjisan-proxy-scraper
    ```


  - install python if not installed
    ```bash
    sudo dnf install python3
    ```
  - install my pypi packages
    ```bash
    pip install adjisan-proxy-scraper
    ```


    ```python
    from ProxyScraper import GetProxy

    if __name__ == "__main__":
      
      proxy = GetProxy(type="http", timeout=5, max_workers=20)

      
      proxies = proxy.get()
      print(f"Fetched {len(proxies)} proxies.")

      
      proxy.save("http.txt")
    ```

  > ===================================


pkgId: 6e1f001ba25e29911a38c7b9f69a80ca41d13cc72f840e7fc23a9cbe1ae9ea55
name: python-adlfs-help
arch: noarch
version: 2024.12.0
epoch: 0
release: 1
summary: Development documents and examples for adlfs
url: https://pypi.org/project/adlfs/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adlfs-2024.12.0-1.src.rpm
location_href: Packages/python-adlfs-help-2024.12.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version shields.io](https://img.shields.io/pypi/v/adlfs.svg)](https://pypi.python.org/pypi/adlfs/)
  [![Latest conda-forge version](https://img.shields.io/conda/vn/conda-forge/adlfs?logo=conda-forge)](https://anaconda.org/conda-forge/aldfs)


pkgId: 3d5f8ae7aedf1728591e8ec0dcda0608a55675e012ab03ae7d8c91835cf96bb4
name: python-adstoolbox-help
arch: noarch
version: 1.0.21
epoch: 0
release: 1
summary: Development documents and examples for adstoolbox
url: https://pypi.org/project/adstoolbox/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adstoolbox-1.0.21-1.src.rpm
location_href: Packages/python-adstoolbox-help-1.0.21-1.noarch.rpm
checksum_type: sha256
description:
  `adsToolBox` est une librairie Python conçue pour regrouper toutes les fonctions génériques qui peuvent être utilisées au
  cours des développements liés à **Onyx**. Elle fournit un ensemble d'outils robustes pour :

  - **Gérer des connexions** à des bases de données PostgreSQL et SQL Server.
  - **Créer et gérer des pipelines** de données entre bases, ou encore de tableau vers base.
  - **Chronométrer les échanges de données** pour le suivi des performances.
  - **Journaliser les évènements** en console, en fichier et en base de données.
  - **Gérer l'environnement** via des fichiers `.env`.



  Vous pouvez installer la librairie directement depuis PyPI en utilisant `pip` :
  ```bash
  pip install adsToolBox
  ```



  Des exemple d'utilisation sont disponibles sur ce repo github : [Démo](https://github.com/AlchimieDataSolutions/DemoPy).



  Pour en savoir plus sur ce que fait chaque fonctionnalité du projet, voici le repo du projet
  [adsToolBox](https://github.com/AlchimieDataSolutions/adsGenericFunctions).


pkgId: 8a82ca22507ded1733c3bd6ff860232410f4b0c65ed2c374f1e5e5df6b1b5d22
name: python-advanced-alchemy-help
arch: noarch
version: 0.26.2
epoch: 0
release: 1
summary: Development documents and examples for advanced-alchemy
url: https://docs.advanced-alchemy.litestar.dev/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-advanced-alchemy-0.26.2-1.src.rpm
location_href: Packages/python-advanced-alchemy-help-0.26.2-1.noarch.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable -->
  <p align="center">
    <!-- github-banner-start -->
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/AA%20-%20Banner%20-%20Inline%20-%20Light.svg#gh-light-mode-only" alt="Litestar Logo - Light" width="100%" height="auto" />
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/AA%20-%20Banner%20-%20Inline%20-%20Dark.svg#gh-dark-mode-only" alt="Litestar Logo - Dark" width="100%" height="auto" />
    <!-- github-banner-end -->
  </p>
  <div align="center">
  <!-- markdownlint-restore -->

  <!-- prettier-ignore-start -->

  | Project   |     | Status                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  |-----------|:----|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | CI/CD     |     | [![Latest Release](https://github.com/litestar-org/advanced-alchemy/actions/workflows/publish.yml/badge.svg)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/publish.yml) [![ci](https://github.com/litestar-org/advanced-alchemy/actions/workflows/ci.yml/badge.svg)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/ci.yml) [![Documentation Building](https://github.com/litestar-org/advanced-alchemy/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/litestar-org/advanced-alchemy/actions/workflows/docs.yml)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  | Quality   |     | [![Coverage](https://codecov.io/github/litestar-org/advanced-alchemy/graph/badge.svg?token=vKez4Pycrc)](https://codecov.io/github/litestar-org/advanced-alchemy) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy) [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=litestar-org_advanced-alchemy&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=litestar-org_advanced-alchemy)                                                                                                    |
  | Package   |     | [![PyPI - Version](https://img.shields.io/pypi/v/advanced-alchemy?labelColor=202235&color=edb641&logo=python&logoColor=edb641)](https://badge.fury.io/py/litestar) ![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/litestar?labelColor=202235&color=edb641&logo=python&logoColor=edb641) ![Advanced Alchemy PyPI - Downloads](https://img.shields.io/pypi/dm/advanced-alchemy?logo=python&label=package%20downloads&labelColor=202235&color=edb641&logoColor=edb641)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | Community |     | [![Reddit](https://img.shields.io/reddit/subreddit-subscribers/litestarapi?label=r%2FLitestar&logo=reddit&labelColor=202235&color=edb641&logoColor=edb641)](https://reddit.com/r/litestarapi) [![Discord](https://img.shields.io/discord/919193495116337154?labelColor=202235&color=edb641&label=chat%20on%20discord&logo=discord&logoColor=edb641)](https://discord.gg/litestar) [![Matrix](https://img.shields.io/badge/chat%20on%20Matrix-bridged-202235?labelColor=202235&color=edb641&logo=matrix&logoColor=edb641)](https://matrix.to/#/#litestar:matrix.org) [![Medium](https://img.shields.io/badge/Medium-202235?labelColor=202235&color=edb641&logo=medium&logoColor=edb641)](https://blog.litestar.dev) [![Twitter](https://img.shields.io/twitter/follow/LitestarAPI?labelColor=202235&color=edb641&logo=twitter&logoColor=edb641&style=flat)](https://twitter.com/LitestarAPI) [![Blog](https://img.shields.io/badge/Blog-litestar.dev-202235?logo=blogger&labelColor=202235&color=edb641&logoColor=edb641)](https://blog.litestar.dev)                                                             |
  | Meta      |     | [![Litestar Project](https://img.shields.io/badge/Litestar%20Org-%E2%AD%90%20Advanced%20Alchemy-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://github.com/litestar-org/advanced-alchemy) [![types - Mypy](https://img.shields.io/badge/types-Mypy-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://github.com/python/mypy) [![License - MIT](https://img.shields.io/badge/license-MIT-202235.svg?logo=python&labelColor=202235&color=edb641&logoColor=edb641)](https://spdx.org/licenses/) [![Litestar Sponsors](https://img.shields.io/badge/Sponsor-%E2%9D%A4-%23edb641.svg?&logo=github&logoColor=edb641&labelColor=202235)](https://github.com/sponsors/litestar-org) [![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json&labelColor=202235)](https://github.com/astral-sh/ruff) [![code style - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/format.json&labelColor=202235)](https://github.com/psf/black) |

  </div>



  Check out the [project documentation][project-docs] 📚 for more information.



  A carefully crafted, thoroughly tested, optimized companion library for SQLAlchemy,
  offering:

  - Sync and async repositories, featuring common CRUD and highly optimized bulk operations
  - Integration with major web frameworks including Litestar, Starlette, FastAPI, Sanic
  - Custom-built alembic configuration and CLI with optional framework integration
  - Utility base classes with audit columns, primary keys and utility functions
  - Optimized JSON types including a custom JSON type for Oracle
  - Integrated support for UUID6 and UUID7 using [`uuid-utils`](https://github.com/aminalaee/uuid-utils) (install with the `uuid` extra)
  - Integrated support for Nano ID using [`fastnanoid`](https://github.com/oliverlambson/fastnanoid) (install with the `nanoid` extra)
  - Pre-configured base classes with audit columns UUID or Big Integer primary keys and
    a [sentinel column](https://docs.sqlalchemy.org/en/20/core/connections.html#configuring-sentinel-columns).
  - Synchronous and asynchronous repositories featuring:
      - Common CRUD operations for SQLAlchemy models
      - Bulk inserts, updates, upserts, and deletes with dialect-specific enhancements
      - Integrated counts, pagination, sorting, filtering with `LIKE`, `IN`, and dates before and/or after.
  - Tested support for multiple database backends including:
      - SQLite via [aiosqlite](https://aiosqlite.omnilib.dev/en/stable/) or [sqlite](https://docs.python.org/3/library/sqlite3.html)
      - Postgres via [asyncpg](https://magicstack.github.io/asyncpg/current/) or [psycopg3 (async or sync)](https://www.psycopg.org/psycopg3/)
      - MySQL via [asyncmy](https://github.com/long2ice/asyncmy)
      - Oracle via [oracledb (async or sync)](https://oracle.github.io/python-oracledb/) (tested on 18c and 23c)
      - Google Spanner via [spanner-sqlalchemy](https://github.com/googleapis/python-spanner-sqlalchemy/)
      - DuckDB via [duckdb_engine](https://github.com/Mause/duckdb_engine)
      - Microsoft SQL Server via [pyodbc](https://github.com/mkleehammer/pyodbc) or [aioodbc](https://github.com/aio-libs/aioodbc)
      - CockroachDB via [sqlalchemy-cockroachdb (async or sync)](https://github.com/cockroachdb/sqlalchemy-cockroachdb)
  - ...and much more





  ```shell
  pip install advanced-alchemy
  ```

  > [!IMPORTANT]\
  > Check out [the installation guide][install-guide] in our official documentation!



  Advanced Alchemy includes a set of asynchronous and synchronous repository classes for easy CRUD
  operations on your SQLAlchemy models.
  <!-- markdownlint-disable -->
  <details>
  <summary>Click to expand the example</summary>
  <!-- markdownlint-restore -->

  ```python
  from advanced_alchemy.base import UUIDBase
  from advanced_alchemy.filters import LimitOffset
  from advanced_alchemy.repository import SQLAlchemySyncRepository
  from sqlalchemy import create_engine
  from sqlalchemy.orm import Mapped, sessionmaker


  class User(UUIDBase):
      
      __tablename__ = "user_account"  # type: ignore[assignment]
      email: Mapped[str]
      name: Mapped[str]


  class UserRepository(SQLAlchemySyncRepository[User]):
      """User repository."""

      model_type = User



  engine = create_engine("duckdb:///:memory:")
  session_factory = sessionmaker(engine, expire_on_commit=False)


  with engine.begin() as conn:
      User.metadata.create_all(conn)

  with session_factory() as db_session:
      repo = UserRepository(session=db_session)
      
      bulk_users = [
          {"email": 'cody@litestar.dev', 'name': 'Cody'},
          {"email": 'janek@litestar.dev', 'name': 'Janek'},
          {"email": 'peter@litestar.dev', 'name': 'Peter'},
          {"email": 'jacob@litestar.dev', 'name': 'Jacob'}
      ]
      objs = repo.add_many([User(**raw_user) for raw_user in bulk_users])
      db_session.commit()
      print(f"Created {len(objs)} new objects.")

      
      created_objs, total_objs = repo.list_and_count(LimitOffset(limit=10, offset=0), name="Cody")
      print(f"Selected {len(created_objs)} records out of a total of {total_objs}.")

      
      deleted_objs = repo.delete_many([new_obj.id for new_obj in created_objs])
      print(f"Removed {len(deleted_objs)} records out of a total of {total_objs}.")

      
      remaining_count = repo.count()
      print(f"Found {remaining_count} remaining records after delete.")
  ```

  </details>

  For a full standalone example, see the sample [here][standalone-example]



  Advanced Alchemy includes an additional service class to make working with a repository easier.
  This class is designed to accept data as a dictionary or SQLAlchemy model,
  and it will handle the type conversions for you.
  <!-- markdownlint-disable -->
  <details>
  <summary>Here's the same example from above but using a service to create the data:</summary>
  <!-- markdownlint-restore -->

  ```python
  from advanced_alchemy.base import UUIDBase
  from advanced_alchemy.filters import LimitOffset
  from advanced_alchemy import SQLAlchemySyncRepository, SQLAlchemySyncRepositoryService
  from sqlalchemy import create_engine
  from sqlalchemy.orm import Mapped, sessionmaker


  class User(UUIDBase):
      
      __tablename__ = "user_account"  # type: ignore[assignment]
      email: Mapped[str]
      name: Mapped[str]


  class UserRepository(SQLAlchemySyncRepository[User]):
      """User repository."""

      model_type = User


  class UserService(SQLAlchemySyncRepositoryService[User]):
      """User repository."""

      repository_type = UserRepository



  engine = create_engine("duckdb:///:memory:")
  session_factory = sessionmaker(engine, expire_on_commit=False)


  with engine.begin() as conn:
      User.metadata.create_all(conn)

  with session_factory() as db_session:
      service = UserService(session=db_session)
      
      objs = service.create_many([
          {"email": 'cody@litestar.dev', 'name': 'Cody'},
          {"email": 'janek@litestar.dev', 'name': 'Janek'},
          {"email": 'peter@litestar.dev', 'name': 'Peter'},
          {"email": 'jacob@litestar.dev', 'name': 'Jacob'}
      ])
      print(objs)
      print(f"Created {len(objs)} new objects.")

      
      created_objs, total_objs = service.list_and_count(LimitOffset(limit=10, offset=0), name="Cody")
      print(f"Selected {len(created_objs)} records out of a total of {total_objs}.")

      
      deleted_objs = service.delete_many([new_obj.id for new_obj in created_objs])
      print(f"Removed {len(deleted_objs)} records out of a total of {total_objs}.")

      
      remaining_count = service.count()
      print(f"Found {remaining_count} remaining records after delete.")
  ```

  </details>



  Advanced Alchemy works with nearly all Python web frameworks.
  Several helpers for popular libraries are included, and additional PRs to support others are welcomed.



  Advanced Alchemy is the official SQLAlchemy integration for Litestar.

  In addition to installing with `pip install advanced-alchemy`,
  it can also be installed as a Litestar extra with `pip install litestar[sqlalchemy]`.

  <!-- markdownlint-disable -->
  <details>
  <summary>Litestar Example</summary>
  <!-- markdownlint-restore -->

  ```python
  from litestar import Litestar
  from litestar.plugins.sqlalchemy import SQLAlchemyPlugin, SQLAlchemyAsyncConfig




  alchemy = SQLAlchemyPlugin(
    config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"),
  )
  app = Litestar(plugins=[alchemy])
  ```

  </details>

  For a full Litestar example, check [here][litestar-example]



  <!-- markdownlint-disable -->
  <details>
  <summary>FastAPI Example</summary>
  <!-- markdownlint-restore -->

  ```python
  from fastapi import FastAPI

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.starlette import StarletteAdvancedAlchemy

  app = FastAPI()
  alchemy = StarletteAdvancedAlchemy(
      config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"), app=app,
  )
  ```

  </details>

  For a full FastAPI example, see [here][fastapi-example]



  <!-- markdownlint-disable -->
  <details>
  <summary>Pre-built Example Apps</summary>
  <!-- markdownlint-restore -->

  ```python
  from starlette.applications import Starlette

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.starlette import StarletteAdvancedAlchemy

  app = Starlette()
  alchemy = StarletteAdvancedAlchemy(
      config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"), app=app,
  )
  ```

  </details>



  <!-- markdownlint-disable -->
  <details>
  <summary>Pre-built Example Apps</summary>
  <!-- markdownlint-restore -->

  ```python
  from sanic import Sanic
  from sanic_ext import Extend

  from advanced_alchemy.config import SQLAlchemyAsyncConfig
  from advanced_alchemy.extensions.sanic import SanicAdvancedAlchemy

  app = Sanic("AlchemySanicApp")
  alchemy = SanicAdvancedAlchemy(
      sqlalchemy_config=SQLAlchemyAsyncConfig(connection_string="sqlite+aiosqlite:///test.sqlite"),
  )
  Extend.register(alchemy)
  ```

  </details>



  All [Litestar Organization][litestar-org] projects will always be a community-centered, available for contributions of any size.

  Before contributing, please review the [contribution guide][contributing].

  If you have any questions, reach out to us on [Discord][discord], our org-wide [GitHub discussions][litestar-discussions] page,
  or the [project-specific GitHub discussions page][project-discussions].

  <!-- markdownlint-disable -->
  <hr />
  <p align="center">
    <!-- github-banner-start -->
    <img src="https://raw.githubusercontent.com/litestar-org/branding/main/assets/Branding%20-%20SVG%20-%20Transparent/Organization%20Project%20-%20Banner%20-%20Inline%20-%20Dark.svg" alt="Litestar Logo - Light" width="40%" height="auto" />
    <br>An official <a href="https://github.com/litestar-org">Litestar Organization</a> Project
    <!-- github-banner-end -->
  </p>

  [litestar-org]: https://github.com/litestar-org
  [contributing]: https://docs.advanced-alchemy.litestar.dev/latest/contribution-guide.html
  [discord]: https://discord.gg/litestar
  [litestar-discussions]: https://github.com/orgs/litestar-org/discussions
  [project-discussions]: https://github.com/litestar-org/advanced-alchemy/discussions
  [project-docs]: https://docs.advanced-alchemy.litestar.dev
  [install-guide]: https://docs.advanced-alchemy.litestar.dev/latest/#installation
  [fastapi-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/fastapi.py
  [litestar-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/litestar.py
  [standalone-example]: https://github.com/litestar-org/advanced-alchemy/blob/main/examples/standalone.py


pkgId: 1e5309bf6f6ed15df8fda85dc08cfdf319c01c24592ee126a2b1591124cdfa09
name: python-adversarial-robustness-toolbox-help
arch: noarch
version: 1.19.0
epoch: 0
release: 1
summary: Development documents and examples for adversarial-robustness-toolbox
url: https://github.com/Trusted-AI/adversarial-robustness-toolbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adversarial-robustness-toolbox-1.19.0-1.src.rpm
location_href: Packages/python-adversarial-robustness-toolbox-help-1.19.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="docs/images/art_lfai.png?raw=true" width="467" title="ART logo">
  </p>
  <br />

  ![CodeQL](https://github.com/Trusted-AI/adversarial-robustness-toolbox/workflows/CodeQL/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/adversarial-robustness-toolbox/badge/?version=latest)](http://adversarial-robustness-toolbox.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://badge.fury.io/py/adversarial-robustness-toolbox.svg)](https://badge.fury.io/py/adversarial-robustness-toolbox)
  [![codecov](https://codecov.io/gh/Trusted-AI/adversarial-robustness-toolbox/branch/main/graph/badge.svg)](https://codecov.io/gh/Trusted-AI/adversarial-robustness-toolbox)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/adversarial-robustness-toolbox)](https://pypi.org/project/adversarial-robustness-toolbox/)
  [![slack-img](https://img.shields.io/badge/chat-on%20slack-yellow.svg)](https://ibm-art.slack.com/)
  [![Downloads](https://static.pepy.tech/badge/adversarial-robustness-toolbox)](https://pepy.tech/project/adversarial-robustness-toolbox)
  [![Downloads](https://static.pepy.tech/badge/adversarial-robustness-toolbox/month)](https://pepy.tech/project/adversarial-robustness-toolbox)
  [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5090/badge)](https://bestpractices.coreinfrastructure.org/projects/5090)

  [中文README请按此处](README-cn.md)

  <p align="center">
    <img src="https://raw.githubusercontent.com/lfai/artwork/master/lfaidata-assets/lfaidata-project-badge/graduate/color/lfaidata-project-badge-graduate-color.png" alt="LF AI & Data" width="300"/>
  </p>

  Adversarial Robustness Toolbox (ART) is a Python library for Machine Learning Security. ART is hosted by the
  [Linux Foundation AI & Data Foundation](https://lfaidata.foundation) (LF AI & Data). ART provides tools that enable
  developers and researchers to defend and evaluate Machine Learning models and applications against the
  adversarial threats of Evasion, Poisoning, Extraction, and Inference. ART supports all popular machine learning frameworks
  (TensorFlow, Keras, PyTorch, MXNet, scikit-learn, XGBoost, LightGBM, CatBoost, GPy, etc.), all data types
  (images, tables, audio, video, etc.) and machine learning tasks (classification, object detection, speech recognition,
  generation, certification, etc.).



  <p align="center">
    <img src="docs/images/adversarial_threats_attacker.png?raw=true" width="400" title="ART logo">
    <img src="docs/images/adversarial_threats_art.png?raw=true" width="400" title="ART logo">
  </p>
  <br />



  <p align="center">
    <img src="docs/images/white_hat_blue_red.png?raw=true" width="800" title="ART Red and Blue Teams">
  </p>
  <br />



  | **[Get Started][get-started]**     | **[Documentation][documentation]**     | **[Contributing][contributing]**           |
  |-------------------------------------|-------------------------------|-----------------------------------|
  | - [Installation][installation]<br>- [Examples](examples/README.md)<br>- [Notebooks](notebooks/README.md) | - [Attacks][attacks]<br>- [Defences][defences]<br>- [Estimators][estimators]<br>- [Metrics][metrics]<br>- [Technical Documentation](https://adversarial-robustness-toolbox.readthedocs.io) | - [Slack](https://ibm-art.slack.com), [Invitation](https://join.slack.com/t/ibm-art/shared_invite/enQtMzkyOTkyODE4NzM4LTA4NGQ1OTMxMzFmY2Q1MzE1NWI2MmEzN2FjNGNjOGVlODVkZDE0MjA1NTA4OGVkMjVkNmQ4MTY1NmMyOGM5YTg)<br>- [Contributing](CONTRIBUTING.md)<br>- [Roadmap][roadmap]<br>- [Citing][citing] |

  [get-started]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Get-Started
  [attacks]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Attacks
  [defences]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Defences
  [estimators]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Estimators
  [metrics]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/ART-Metrics
  [contributing]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Contributing
  [documentation]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Documentation
  [installation]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Get-Started#setup
  [roadmap]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Roadmap
  [citing]: https://github.com/Trusted-AI/adversarial-robustness-toolbox/wiki/Contributing#citing-art

  The library is under continuous development. Feedback, bug reports and contributions are very welcome!


  This material is partially based upon work supported by the Defense Advanced Research Projects Agency (DARPA) under
  Contract No. HR001120C0013. Any opinions, findings and conclusions or recommendations expressed in this material are
  those of the author(s) and do not necessarily reflect the views of the Defense Advanced Research Projects Agency (DARPA).


pkgId: 7ad4a137833b708174f31a466eba5bd56303e7b17e4f7ceb27e4677f416acfb6
name: python-advertools-help
arch: noarch
version: 0.16.3
epoch: 0
release: 1
summary: Development documents and examples for advertools
url: https://github.com/eliasdabbas/advertools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-advertools-0.16.3-1.src.rpm
location_href: Packages/python-advertools-help-0.16.3-1.noarch.rpm
checksum_type: sha256
description:
  | A digital marketer is a data scientist.
  | Your job is to manage, manipulate, visualize, communicate, understand,
    and make decisions based on data.
  You might be doing basic stuff, like copying and pasting text on spread
  sheets, you might be running large scale automated platforms with
  sophisticated algorithms, or somewhere in between. In any case your job
  is all about working with data.
  As a data scientist you don't spend most of your time producing cool
  visualizations or finding great insights. The majority of your time is spent
  wrangling with URLs, figuring out how to stitch together two tables, hoping
  that the dates, won't break, without you knowing, or trying to generate the
  next 124,538 keywords for an upcoming campaign, by the end of the week!
  ``advertools`` is a Python package that can hopefully make that part of your job a little easier.


pkgId: a07e32dcf627ac13210215372ecd4707ca797cf8ee2cd6b1cec6c30ac2ae6511
name: python-aeiva-help
arch: noarch
version: 0.8.2.4
epoch: 0
release: 1
summary: Development documents and examples for aeiva
url: https://pypi.org/project/aeiva/
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aeiva-0.8.2.4-1.src.rpm
location_href: Packages/python-aeiva-help-0.8.2.4-1.noarch.rpm
checksum_type: sha256
description:
  <!--![gradio_chatbot](assets/aeiva-chat-gradio-demo.png)-->
  <p align="center" width="100%">
      <img src="assets/aeiva-chat-gradio-demo.png" alt="Gradio Chatbot" style="width: 80%; display: block; margin: auto;">


pkgId: 1f67749c8687968a0c2af80762a3274c76a790b44cec46b0964d4db8adb9f70a
name: python-aeppl-nightly-help
arch: noarch
version: 0.0.40
epoch: 0
release: 1
summary: Development documents and examples for aeppl-nightly
url: https://github.com/aesara-devs/aeppl
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aeppl-nightly-0.0.40-1.src.rpm
location_href: Packages/python-aeppl-nightly-help-0.0.40-1.noarch.rpm
checksum_type: sha256
description:
  - Convert graphs containing Aesara ``RandomVariable``\s into joint
    log-probability graphs
  - Transforms for ``RandomVariable``\s that map constrained support spaces to
    unconstrained spaces (e.g. the extended real numbers), and a rewrite that
    automatically applies these transformations throughout a graph
  - Tools for traversing and transforming graphs containing ``RandomVariable``\s
  - ``RandomVariable``-aware pretty printing and LaTeX output


pkgId: ab10319a5f8ce56456e21f5e906431cbfae851c158cb2fb29a0e085b11f5aec4
name: python-aepsych-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for aepsych
url: https://pypi.org/project/aepsych/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aepsych-0.6.0-1.src.rpm
location_href: Packages/python-aepsych-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  AEPsych is a framework and library for adaptive experimetation in psychophysics and related domains.


  `AEPsych` only supports python 3.10+. We recommend installing `AEPsych` under a virtual environment like
  [Anaconda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html).
  Once you've created a virtual environment for `AEPsych` and activated it, you can install `AEPsych` using pip:

  ```
  pip install aepsych
  ```

  If you're a developer or want to use the latest features, you can install from GitHub using:

  ```
  git clone https://github.com/facebookresearch/aepsych.git
  cd aepsych
  pip install -e .[dev]
  ```


  **See the code examples [here](https://github.com/facebookresearch/aepsych/tree/main/examples).**

  The canonical way of using AEPsych is to launch it in server mode (you can run `aepsych_server` --help to see additional arguments):

  ```
  aepsych_server --port 5555 --ip 0.0.0.0 --db mydatabase.db
  ```

  The server accepts messages over a unix socket, and
  all messages are formatted using [JSON](https://www.json.org/json-en.html). All messages
  have the following format:

  ```
  {
       "type":<TYPE>,
       "message":<MESSAGE>,
  }
  ```

  There are five message types: `setup`, `resume`, `ask`, `tell` and `exit` (see [aepsych/server/message_handlers](https://github.com/facebookresearch/aepsych/tree/main/aepsych/server/message_handlers) for the full set of messages).

  The `setup` message prepares the server for making suggestions and accepting data. The setup
  message can be formatted as either INI or a python dict (similar to JSON) format, and an example
  for psychometric threshold estimation is given in `configs/single_lse_example.ini`. It looks like this:

  ```
  {
      "type":"setup",
      "message":{"config_str":<PASTED CONFIG STRING>}
  }
  ```
  After receiving a setup message, the server responds with a strategy index that can be used
  to resume this setup (for example, for interleaving multiple experiments).


  The `resume` message tells the server to resume a strategy from earlier in the same run. It looks like this:
  ```
  {
      "type":"resume",
      "message":{"strat_id":"0"}
  }
  ```
  After receiving a resume message, the server responds with the strategy index resumed.


  The `ask` message queries the server for the next trial configuration. It looks like this:

  ```
  {
      "type":"ask",
      "message":""
  }
  ```
  After receiving an ask message, the server responds with a configuration in JSON format, for example
  `{"frequency":100, "intensity":0.8}`


  The `tell` message updates the server with the outcome for a trial configuration. Note that the
  `tell` does not need to match with a previously `ask`'d trial. For example, if you are interleaving
  AEPsych runs with a classical staircase, you can still feed AEPsych with the staircase data. A message
  looks like this:
  ```
  {
      "type":"tell",
      "message":{
          "config":{
                  "frequency":100,
                  "intensity":0.8
              },
          "outcome":"1",
      }
  }
  ```

  The `exit` message tells the server to close the socket connection, write strats into the database and terminate current session.
  The message is:
  ```
  {
      "type":"exit",
  }
  ```
  The server closes the connection.


  The data is logged to a SQLite database on disk (by default, `databases/default.db`). The database
  has one table containing all experiment sessions that were run. Then, for each experiment there
  is a table containing all messages sent and received by the server, capable of supporting a
  full replay of the experiment from the server's perspective. This table can be summarized
  into a data frame output (docs forthcoming) and used to visualize data (docs forthcoming).


  See the [CONTRIBUTING](CONTRIBUTING.md) file for how to help out.


  AEPsych licensed CC-BY-NC 4.0, as found in the [LICENSE](LICENSE) file.


  The AEPsych paper is currently under review. In the meanwhile, you can cite our [preprint](https://arxiv.org/abs/2104.09549):

      Owen, L., Browder, J., Letham, B., Stocek, G., Tymms, C., & Shvartsman, M. (2021). Adaptive Nonparametric Psychophysics. http://arxiv.org/abs/2104.09549


pkgId: 2ad41da0b668af2b48b348127dd8bfcef604e03b6cabe0203e57b8c44f41c736
name: python-aerocaps-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for aerocaps
url: https://pypi.org/project/aerocaps/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aerocaps-0.0.0-1.src.rpm
location_href: Packages/python-aerocaps-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Toolkit for design of Class-A, parametric design of aerodynamic surfaces



  For installation of `aerocaps` using the latest stable release, use

  ```shell
  pip install aerocaps
  ```

  To install the bleeding-edge version, use

  ```shell
  git clone https://github.com/mlau154/aerocaps.git
  ```


pkgId: 6c063e7e8807de8537c85ccb6dc31024e6d50568808e61d44287550dd548ba68
name: python-aerocaps-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for aerocaps
url: https://pypi.org/project/aerocaps/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aerocaps-0.0.2-1.src.rpm
location_href: Packages/python-aerocaps-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Toolkit for design of Class-A, parametric design of aerodynamic surfaces



  For installation of `aerocaps` using the latest stable release, open a terminal
  and use the following command:

  ```shell
  pip install aerocaps
  ```

  To install the bleeding-edge version instead, open a terminal
  and use the following command:

  ```shell
  cd <Install-Parent-Location>
  git clone https://github.com/mlau154/aerocaps.git
  cd <Install-Parent-Location>/aerocaps
  pip install .
  ```



  To update `aerocaps` to the newest version from the basic install, use

  ```shell
  pip install aerocaps --upgrade
  ```

  From the bleeding-edge version, use

  ```shell
  cd <Install-Location>
  git pull
  pip install .
  ```


pkgId: 09b5a209c6d56a0ba6aba2912b64e02af42c1309f28e6bb20eb0b66c6c5a7197
name: python-aes-package-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for aes-package
url: https://github.com/yourusername/aes_package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aes-package-0.1-1.src.rpm
location_href: Packages/python-aes-package-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for AES (Advanced Encryption Standard) encryption and decryption.


  - AES-128, AES-192, and AES-256 encryption and decryption.
  - Modular design for ease of use and extension.


  ```bash
  pip install aes_package


pkgId: 9fd0e4eddbaf2fb659b655dccfc7ee0a252761ff6faab50c0464b879d36589fc
name: python-affinidi_tdk_credential_issuance_client-help
arch: noarch
version: 1.36.0
epoch: 0
release: 1
summary: Development documents and examples for affinidi_tdk_credential_issuance_client
url: https://github.com/affinidi/affinidi-tdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-affinidi_tdk_credential_issuance_client-1.36.0-1.src.rpm
location_href: Packages/python-affinidi_tdk_credential_issuance_client-help-1.36.0-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  For more information, please visit [https://github.com/affinidi/affinidi-tdk](https://github.com/affinidi/affinidi-tdk)

  Documentation is available at [https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/credential-issuance/](https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/credential-issuance/)



  Python 3.7+





  If the python package is hosted on a repository, you can install directly using:

  ```sh
  pip install affinidi_tdk_credential_issuance_client
  ```

  Then import the package:

  ```python
  import affinidi_tdk_credential_issuance_client
  ```



  Install via [Setuptools](http://pypi.python.org/pypi/setuptools).

  ```sh
  python setup.py install --user
  ```

  Then import the package:

  ```python
  import affinidi_tdk_credential_issuance_client
  ```



  Execute `pytest` to run the tests.



  Please follow the [installation procedure](#installation--usage) and then run the following:

  ```python

  import time
  import affinidi_tdk_credential_issuance_client
  from affinidi_tdk_credential_issuance_client.rest import ApiException
  from pprint import pprint



  configuration = affinidi_tdk_credential_issuance_client.Configuration(
      host = "https://apse1.api.affinidi.io/cis"
  )







  configuration.api_key['ProjectTokenAuth'] = os.environ["API_KEY"]


  import affinidi_tdk_auth_provider

  stats = {
    apiGatewayUrl,
    keyId,
    passphrase,
    privateKey,
    projectId,
    tokenEndpoint,
    tokenId,
  }
  authProvider = affinidi_tdk_auth_provider.AuthProvider(stats)
  configuration.refresh_api_key_hook = lambda api_client: authProvider.fetch_project_scoped_token()






  with affinidi_tdk_credential_issuance_client.ApiClient(configuration) as api_client:
      
      api_instance = affinidi_tdk_credential_issuance_client.ConfigurationApi(api_client)
      create_issuance_config_input = affinidi_tdk_credential_issuance_client.CreateIssuanceConfigInput() # CreateIssuanceConfigInput | Request body of create configuration

      try:
          api_response = api_instance.create_issuance_config(create_issuance_config_input)
          print("The response of ConfigurationApi->create_issuance_config:\n")
          pprint(api_response)
      except ApiException as e:
          print("Exception when calling ConfigurationApi->create_issuance_config: %s\n" % e)

  ```



  All URIs are relative to *https://apse1.api.affinidi.io/cis*

  | Class              | Method                                                                                                        | HTTP request                                                                            | Description               |
  | ------------------ | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | ------------------------- |
  | _ConfigurationApi_ | [**create_issuance_config**](docs/ConfigurationApi.md#create_issuance_config)                                 | **POST** /v1/configurations                                                             |
  | _ConfigurationApi_ | [**delete_issuance_config_by_id**](docs/ConfigurationApi.md#delete_issuance_config_by_id)                     | **DELETE** /v1/configurations/{configurationId}                                         |
  | _ConfigurationApi_ | [**get_issuance_config_by_id**](docs/ConfigurationApi.md#get_issuance_config_by_id)                           | **GET** /v1/configurations/{configurationId}                                            |
  | _ConfigurationApi_ | [**get_issuance_config_list**](docs/ConfigurationApi.md#get_issuance_config_list)                             | **GET** /v1/configurations                                                              |
  | _ConfigurationApi_ | [**update_issuance_config_by_id**](docs/ConfigurationApi.md#update_issuance_config_by_id)                     | **PUT** /v1/configurations/{configurationId}                                            |
  | _CredentialsApi_   | [**generate_credentials**](docs/CredentialsApi.md#generate_credentials)                                       | **POST** /v1/{projectId}/credential                                                     |
  | _DefaultApi_       | [**change_credential_status**](docs/DefaultApi.md#change_credential_status)                                   | **POST** /v1/{projectId}/configurations/{configurationId}/issuance/change-status        | change credential status. |
  | _DefaultApi_       | [**list_issuance_data_records**](docs/DefaultApi.md#list_issuance_data_records)                               | **GET** /v1/{projectId}/configurations/{configurationId}/issuance/issuance-data-records | List records              |
  | _IssuanceApi_      | [**issuance_state**](docs/IssuanceApi.md#issuance_state)                                                      | **GET** /v1/{projectId}/issuance/state/{issuanceId}                                     |
  | _IssuanceApi_      | [**list_issuance**](docs/IssuanceApi.md#list_issuance)                                                        | **GET** /v1/{projectId}/issuance                                                        |
  | _IssuanceApi_      | [**start_issuance**](docs/IssuanceApi.md#start_issuance)                                                      | **POST** /v1/{projectId}/issuance/start                                                 |
  | _OfferApi_         | [**get_credential_offer**](docs/OfferApi.md#get_credential_offer)                                             | **GET** /v1/{projectId}/offers/{issuanceId}                                             |
  | _WellKnownApi_     | [**get_well_known_open_id_credential_issuer**](docs/WellKnownApi.md#get_well_known_open_id_credential_issuer) | **GET** /v1/{projectId}/.well-known/openid-credential-issuer                            |



  - [ActionForbiddenError](docs/ActionForbiddenError.md)
  - [ActionForbiddenErrorDetailsInner](docs/ActionForbiddenErrorDetailsInner.md)
  - [ChangeCredentialStatusInput](docs/ChangeCredentialStatusInput.md)
  - [CorsGenerateCredentialsOK](docs/CorsGenerateCredentialsOK.md)
  - [CorsGetCredentialOfferOK](docs/CorsGetCredentialOfferOK.md)
  - [CorsGetWellKnownOpenIdCredentialIssuerOK](docs/CorsGetWellKnownOpenIdCredentialIssuerOK.md)
  - [CreateCredentialInput](docs/CreateCredentialInput.md)
  - [CreateIssuanceConfig400Response](docs/CreateIssuanceConfig400Response.md)
  - [CreateIssuanceConfigInput](docs/CreateIssuanceConfigInput.md)
  - [CredentialIssuanceIdExistError](docs/CredentialIssuanceIdExistError.md)
  - [CredentialOfferClaimedError](docs/CredentialOfferClaimedError.md)
  - [CredentialOfferExpiredError](docs/CredentialOfferExpiredError.md)
  - [CredentialOfferResponse](docs/CredentialOfferResponse.md)
  - [CredentialOfferResponseGrants](docs/CredentialOfferResponseGrants.md)
  - [CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode](docs/CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCode.md)
  - [CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode](docs/CredentialOfferResponseGrantsUrnIetfParamsOauthGrantTypePreAuthorizedCodeTxCode.md)
  - [CredentialProof](docs/CredentialProof.md)
  - [CredentialResponse](docs/CredentialResponse.md)
  - [CredentialResponseDeferred](docs/CredentialResponseDeferred.md)
  - [CredentialResponseImmediate](docs/CredentialResponseImmediate.md)
  - [CredentialResponseImmediateCNonceExpiresIn](docs/CredentialResponseImmediateCNonceExpiresIn.md)
  - [CredentialResponseImmediateCredential](docs/CredentialResponseImmediateCredential.md)
  - [CredentialSubjectNotValidError](docs/CredentialSubjectNotValidError.md)
  - [CredentialSupportedObject](docs/CredentialSupportedObject.md)
  - [DeferredCredentialInput](docs/DeferredCredentialInput.md)
  - [FlowData](docs/FlowData.md)
  - [FlowDataStatusListsDetailsInner](docs/FlowDataStatusListsDetailsInner.md)
  - [GenerateCredentials400Response](docs/GenerateCredentials400Response.md)
  - [GetCredentialOffer400Response](docs/GetCredentialOffer400Response.md)
  - [InvalidCredentialRequestError](docs/InvalidCredentialRequestError.md)
  - [InvalidCredentialTypeError](docs/InvalidCredentialTypeError.md)
  - [InvalidIssuerWalletError](docs/InvalidIssuerWalletError.md)
  - [InvalidJwtTokenError](docs/InvalidJwtTokenError.md)
  - [InvalidParameterError](docs/InvalidParameterError.md)
  - [InvalidProofError](docs/InvalidProofError.md)
  - [IssuanceConfigDto](docs/IssuanceConfigDto.md)
  - [IssuanceConfigListResponse](docs/IssuanceConfigListResponse.md)
  - [IssuanceConfigMiniDto](docs/IssuanceConfigMiniDto.md)
  - [IssuanceStateResponse](docs/IssuanceStateResponse.md)
  - [ListIssuanceRecordResponse](docs/ListIssuanceRecordResponse.md)
  - [ListIssuanceResponse](docs/ListIssuanceResponse.md)
  - [ListIssuanceResponseIssuancesInner](docs/ListIssuanceResponseIssuancesInner.md)
  - [MissingHolderDidError](docs/MissingHolderDidError.md)
  - [NotFoundError](docs/NotFoundError.md)
  - [ProjectCredentialConfigExistError](docs/ProjectCredentialConfigExistError.md)
  - [ProjectCredentialConfigNotExistError](docs/ProjectCredentialConfigNotExistError.md)
  - [StartIssuance400Response](docs/StartIssuance400Response.md)
  - [StartIssuanceInput](docs/StartIssuanceInput.md)
  - [StartIssuanceInputDataInner](docs/StartIssuanceInputDataInner.md)
  - [StartIssuanceInputDataInnerMetaData](docs/StartIssuanceInputDataInnerMetaData.md)
  - [StartIssuanceInputDataInnerStatusListDetailsInner](docs/StartIssuanceInputDataInnerStatusListDetailsInner.md)
  - [StartIssuanceResponse](docs/StartIssuanceResponse.md)
  - [SupportedCredentialMetadata](docs/SupportedCredentialMetadata.md)
  - [SupportedCredentialMetadataDisplayInner](docs/SupportedCredentialMetadataDisplayInner.md)
  - [SupportedCredentialMetadataDisplayInnerLogo](docs/SupportedCredentialMetadataDisplayInnerLogo.md)
  - [UpdateIssuanceConfigInput](docs/UpdateIssuanceConfigInput.md)
  - [VcClaimedError](docs/VcClaimedError.md)
  - [WellKnownOpenIdCredentialIssuerResponse](docs/WellKnownOpenIdCredentialIssuerResponse.md)
  - [WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner](docs/WellKnownOpenIdCredentialIssuerResponseCredentialsSupportedInner.md)

  <a id="documentation-for-authorization"></a>



  Authentication schemes defined for the API:
  <a id="AwsSigV4"></a>



  - **Type**: API key
  - **API key parameter name**: Authorization
  - **Location**: HTTP header

  <a id="ApiKey"></a>



  - **Type**: API key
  - **API key parameter name**: x-api-key
  - **Location**: HTTP header

  <a id="bearerAuth"></a>



  - **Type**: Bearer authentication (JWT)

  <a id="ConsumerTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="UserTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="ProjectTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="HeritageTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header



  info@affinidi.com


pkgId: 546534ef7f11b50e1c44659c7f38d049d316a2bbd967960ad1971ad91a36cd93
name: python-affinidi_tdk_credential_verification_client-help
arch: noarch
version: 1.33.0
epoch: 0
release: 1
summary: Development documents and examples for affinidi_tdk_credential_verification_client
url: https://github.com/affinidi/affinidi-tdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-affinidi_tdk_credential_verification_client-1.33.0-1.src.rpm
location_href: Packages/python-affinidi_tdk_credential_verification_client-help-1.33.0-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  For more information, please visit [https://github.com/affinidi/affinidi-tdk](https://github.com/affinidi/affinidi-tdk)

  Documentation is available at [https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/credential-verification](https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/credential-verification)



  Python 3.7+





  If the python package is hosted on a repository, you can install directly using:

  ```sh
  pip install affinidi_tdk_credential_verification_client
  ```

  Then import the package:

  ```python
  import affinidi_tdk_credential_verification_client
  ```



  Install via [Setuptools](http://pypi.python.org/pypi/setuptools).

  ```sh
  python setup.py install --user
  ```

  Then import the package:

  ```python
  import affinidi_tdk_credential_verification_client
  ```



  Execute `pytest` to run the tests.



  Please follow the [installation procedure](#installation--usage) and then run the following:

  ```python

  import time
  import affinidi_tdk_credential_verification_client
  from affinidi_tdk_credential_verification_client.rest import ApiException
  from pprint import pprint



  configuration = affinidi_tdk_credential_verification_client.Configuration(
      host = "https://apse1.api.affinidi.io/ver"
  )







  configuration.api_key['ProjectTokenAuth'] = os.environ["API_KEY"]


  import affinidi_tdk_auth_provider

  stats = {
    apiGatewayUrl,
    keyId,
    passphrase,
    privateKey,
    projectId,
    tokenEndpoint,
    tokenId,
  }
  authProvider = affinidi_tdk_auth_provider.AuthProvider(stats)
  configuration.refresh_api_key_hook = lambda api_client: authProvider.fetch_project_scoped_token()






  with affinidi_tdk_credential_verification_client.ApiClient(configuration) as api_client:
      
      api_instance = affinidi_tdk_credential_verification_client.DefaultApi(api_client)
      verify_credential_input = affinidi_tdk_credential_verification_client.VerifyCredentialInput() # VerifyCredentialInput | VerifyCredentials

      try:
          
          api_response = api_instance.verify_credentials(verify_credential_input)
          print("The response of DefaultApi->verify_credentials:\n")
          pprint(api_response)
      except ApiException as e:
          print("Exception when calling DefaultApi->verify_credentials: %s\n" % e)

  ```



  All URIs are relative to *https://apse1.api.affinidi.io/ver*

  | Class        | Method                                                            | HTTP request                     | Description  |
  | ------------ | ----------------------------------------------------------------- | -------------------------------- | ------------ |
  | _DefaultApi_ | [**verify_credentials**](docs/DefaultApi.md#verify_credentials)   | **POST** /v1/verifier/verify-vcs | Verifying VC |
  | _DefaultApi_ | [**verify_presentation**](docs/DefaultApi.md#verify_presentation) | **POST** /v1/verifier/verify-vp  | Verifying VP |



  - [Constraints](docs/Constraints.md)
  - [ConstraintsStatuses](docs/ConstraintsStatuses.md)
  - [CredentialRequirements](docs/CredentialRequirements.md)
  - [CredentialRequirementsConstraints](docs/CredentialRequirementsConstraints.md)
  - [Descriptor](docs/Descriptor.md)
  - [Error](docs/Error.md)
  - [ErrorDetail](docs/ErrorDetail.md)
  - [EvaluateVpOutput](docs/EvaluateVpOutput.md)
  - [Field](docs/Field.md)
  - [Filter](docs/Filter.md)
  - [FilterConst](docs/FilterConst.md)
  - [FilterItems](docs/FilterItems.md)
  - [Format](docs/Format.md)
  - [FreeFormObject](docs/FreeFormObject.md)
  - [HolderSubject](docs/HolderSubject.md)
  - [InputDescriptor](docs/InputDescriptor.md)
  - [InvalidParameterError](docs/InvalidParameterError.md)
  - [JwtObject](docs/JwtObject.md)
  - [LdpObject](docs/LdpObject.md)
  - [NestedDescriptor](docs/NestedDescriptor.md)
  - [NotFoundError](docs/NotFoundError.md)
  - [NotFoundErrorDetailsInner](docs/NotFoundErrorDetailsInner.md)
  - [PdStatus](docs/PdStatus.md)
  - [PresentationDefinition](docs/PresentationDefinition.md)
  - [PresentationSubmission](docs/PresentationSubmission.md)
  - [SubmissionRequirement](docs/SubmissionRequirement.md)
  - [ValidateJwtInput](docs/ValidateJwtInput.md)
  - [ValidateJwtOutput](docs/ValidateJwtOutput.md)
  - [VerifyCredentialInput](docs/VerifyCredentialInput.md)
  - [VerifyCredentialOutput](docs/VerifyCredentialOutput.md)
  - [VerifyPresentationInput](docs/VerifyPresentationInput.md)
  - [VerifyPresentationOutput](docs/VerifyPresentationOutput.md)
  - [VerifyPresentationOutputErrors](docs/VerifyPresentationOutputErrors.md)
  - [W3cCredential](docs/W3cCredential.md)
  - [W3cCredentialCredentialSchema](docs/W3cCredentialCredentialSchema.md)
  - [W3cCredentialCredentialSubject](docs/W3cCredentialCredentialSubject.md)
  - [W3cCredentialHolder](docs/W3cCredentialHolder.md)
  - [W3cCredentialStatus](docs/W3cCredentialStatus.md)
  - [W3cPresentation](docs/W3cPresentation.md)
  - [W3cPresentationContext](docs/W3cPresentationContext.md)
  - [W3cPresentationContextOneOfInner](docs/W3cPresentationContextOneOfInner.md)
  - [W3cProof](docs/W3cProof.md)

  <a id="documentation-for-authorization"></a>



  Authentication schemes defined for the API:
  <a id="UserTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="ProjectTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header



  info@affinidi.com


pkgId: d569d07fcce800a86f3f58b39c6755dabd8e094c81ec72d39875269e000d2672
name: python-affinidi_tdk_iam_client-help
arch: noarch
version: 1.33.0
epoch: 0
release: 1
summary: Development documents and examples for affinidi_tdk_iam_client
url: https://github.com/affinidi/affinidi-tdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-affinidi_tdk_iam_client-1.33.0-1.src.rpm
location_href: Packages/python-affinidi_tdk_iam_client-help-1.33.0-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  For more information, please visit [https://github.com/affinidi/affinidi-tdk](https://github.com/affinidi/affinidi-tdk)

  Documentation is available at [https://docs.affinidi.com/dev-tools/affinidi-tdk](https://docs.affinidi.com/dev-tools/affinidi-tdk)



  Python 3.7+





  If the python package is hosted on a repository, you can install directly using:

  ```sh
  pip install affinidi_tdk_iam_client
  ```

  Then import the package:

  ```python
  import affinidi_tdk_iam_client
  ```



  Install via [Setuptools](http://pypi.python.org/pypi/setuptools).

  ```sh
  python setup.py install --user
  ```

  Then import the package:

  ```python
  import affinidi_tdk_iam_client
  ```



  Execute `pytest` to run the tests.



  Please follow the [installation procedure](#installation--usage) and then run the following:

  ```python

  import time
  import affinidi_tdk_iam_client
  from affinidi_tdk_iam_client.rest import ApiException
  from pprint import pprint



  configuration = affinidi_tdk_iam_client.Configuration(
      host = "https://apse1.api.affinidi.io/iam"
  )




  with affinidi_tdk_iam_client.ApiClient(configuration) as api_client:
      
      api_instance = affinidi_tdk_iam_client.ConsumerAuthApi(api_client)
      consumer_auth_token_endpoint_input = affinidi_tdk_iam_client.ConsumerAuthTokenEndpointInput() # ConsumerAuthTokenEndpointInput | ConsumerAuthTokenEndpoint

      try:
          
          api_response = api_instance.consumer_auth_token_endpoint(consumer_auth_token_endpoint_input)
          print("The response of ConsumerAuthApi->consumer_auth_token_endpoint:\n")
          pprint(api_response)
      except ApiException as e:
          print("Exception when calling ConsumerAuthApi->consumer_auth_token_endpoint: %s\n" % e)

  ```



  All URIs are relative to *https://apse1.api.affinidi.io/iam*

  | Class             | Method                                                                                   | HTTP request                                     | Description                           |
  | ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------ | ------------------------------------- |
  | _ConsumerAuthApi_ | [**consumer_auth_token_endpoint**](docs/ConsumerAuthApi.md#consumer_auth_token_endpoint) | **POST** /v1/consumer/oauth2/token               | The Consumer OAuth 2.0 Token Endpoint |
  | _DefaultApi_      | [**v1_auth_proxy_delete**](docs/DefaultApi.md#v1_auth_proxy_delete)                      | **DELETE** /v1/auth/{proxy+}                     |
  | _DefaultApi_      | [**v1_auth_proxy_get**](docs/DefaultApi.md#v1_auth_proxy_get)                            | **GET** /v1/auth/{proxy+}                        |
  | _DefaultApi_      | [**v1_auth_proxy_patch**](docs/DefaultApi.md#v1_auth_proxy_patch)                        | **PATCH** /v1/auth/{proxy+}                      |
  | _DefaultApi_      | [**v1_auth_proxy_post**](docs/DefaultApi.md#v1_auth_proxy_post)                          | **POST** /v1/auth/{proxy+}                       |
  | _DefaultApi_      | [**v1_auth_proxy_put**](docs/DefaultApi.md#v1_auth_proxy_put)                            | **PUT** /v1/auth/{proxy+}                        |
  | _DefaultApi_      | [**v1_idp_proxy_delete**](docs/DefaultApi.md#v1_idp_proxy_delete)                        | **DELETE** /v1/idp/{proxy+}                      |
  | _DefaultApi_      | [**v1_idp_proxy_get**](docs/DefaultApi.md#v1_idp_proxy_get)                              | **GET** /v1/idp/{proxy+}                         |
  | _DefaultApi_      | [**v1_idp_proxy_patch**](docs/DefaultApi.md#v1_idp_proxy_patch)                          | **PATCH** /v1/idp/{proxy+}                       |
  | _DefaultApi_      | [**v1_idp_proxy_post**](docs/DefaultApi.md#v1_idp_proxy_post)                            | **POST** /v1/idp/{proxy+}                        |
  | _DefaultApi_      | [**v1_idp_proxy_put**](docs/DefaultApi.md#v1_idp_proxy_put)                              | **PUT** /v1/idp/{proxy+}                         |
  | _PoliciesApi_     | [**get_policies**](docs/PoliciesApi.md#get_policies)                                     | **GET** /v1/policies/principals/{principalId}    |
  | _PoliciesApi_     | [**update_policies**](docs/PoliciesApi.md#update_policies)                               | **PUT** /v1/policies/principals/{principalId}    |
  | _ProjectsApi_     | [**add_principal_to_project**](docs/ProjectsApi.md#add_principal_to_project)             | **POST** /v1/projects/principals                 |
  | _ProjectsApi_     | [**create_project**](docs/ProjectsApi.md#create_project)                                 | **POST** /v1/projects                            |
  | _ProjectsApi_     | [**delete_principal_from_project**](docs/ProjectsApi.md#delete_principal_from_project)   | **DELETE** /v1/projects/principals/{principalId} |
  | _ProjectsApi_     | [**list_principals_of_project**](docs/ProjectsApi.md#list_principals_of_project)         | **GET** /v1/projects/principals                  |
  | _ProjectsApi_     | [**list_project**](docs/ProjectsApi.md#list_project)                                     | **GET** /v1/projects                             |
  | _ProjectsApi_     | [**update_project**](docs/ProjectsApi.md#update_project)                                 | **PATCH** /v1/projects/{projectId}               |
  | _StsApi_          | [**create_project_scoped_token**](docs/StsApi.md#create_project_scoped_token)            | **POST** /v1/sts/create-project-scoped-token     |
  | _StsApi_          | [**whoami**](docs/StsApi.md#whoami)                                                      | **GET** /v1/sts/whoami                           |
  | _TokensApi_       | [**create_token**](docs/TokensApi.md#create_token)                                       | **POST** /v1/tokens                              |
  | _TokensApi_       | [**delete_token**](docs/TokensApi.md#delete_token)                                       | **DELETE** /v1/tokens/{tokenId}                  |
  | _TokensApi_       | [**get_token**](docs/TokensApi.md#get_token)                                             | **GET** /v1/tokens/{tokenId}                     |
  | _TokensApi_       | [**list_projects_of_token**](docs/TokensApi.md#list_projects_of_token)                   | **GET** /v1/tokens/{tokenId}/projects            |
  | _TokensApi_       | [**list_token**](docs/TokensApi.md#list_token)                                           | **GET** /v1/tokens                               |
  | _TokensApi_       | [**update_token**](docs/TokensApi.md#update_token)                                       | **PATCH** /v1/tokens/{tokenId}                   |
  | _WellKnownApi_    | [**get_well_known_did**](docs/WellKnownApi.md#get_well_known_did)                        | **GET** /.well-known/did.json                    |
  | _WellKnownApi_    | [**get_well_known_jwks**](docs/WellKnownApi.md#get_well_known_jwks)                      | **GET** /.well-known/jwks.json                   |



  - [ActionForbiddenError](docs/ActionForbiddenError.md)
  - [AddUserToProjectInput](docs/AddUserToProjectInput.md)
  - [ConsumerAuthTokenEndpointInput](docs/ConsumerAuthTokenEndpointInput.md)
  - [ConsumerAuthTokenEndpointOutput](docs/ConsumerAuthTokenEndpointOutput.md)
  - [CorsConsumerAuthTokenEndpointOK](docs/CorsConsumerAuthTokenEndpointOK.md)
  - [CreateProjectInput](docs/CreateProjectInput.md)
  - [CreateProjectScopedTokenInput](docs/CreateProjectScopedTokenInput.md)
  - [CreateProjectScopedTokenOutput](docs/CreateProjectScopedTokenOutput.md)
  - [CreateTokenInput](docs/CreateTokenInput.md)
  - [GetWellKnownDidOK](docs/GetWellKnownDidOK.md)
  - [InvalidDIDError](docs/InvalidDIDError.md)
  - [InvalidJwtTokenError](docs/InvalidJwtTokenError.md)
  - [InvalidParameterError](docs/InvalidParameterError.md)
  - [JsonWebKeyDto](docs/JsonWebKeyDto.md)
  - [JsonWebKeySetDto](docs/JsonWebKeySetDto.md)
  - [NotFoundError](docs/NotFoundError.md)
  - [PolicyDto](docs/PolicyDto.md)
  - [PolicyStatementDto](docs/PolicyStatementDto.md)
  - [PrincipalCannotBeDeletedError](docs/PrincipalCannotBeDeletedError.md)
  - [PrincipalDoesNotBelongToProjectError](docs/PrincipalDoesNotBelongToProjectError.md)
  - [ProjectDto](docs/ProjectDto.md)
  - [ProjectList](docs/ProjectList.md)
  - [ProjectWithPolicyDto](docs/ProjectWithPolicyDto.md)
  - [ProjectWithPolicyList](docs/ProjectWithPolicyList.md)
  - [PublicKeyCannotBeResolvedFromDidError](docs/PublicKeyCannotBeResolvedFromDidError.md)
  - [ServiceErrorResponse](docs/ServiceErrorResponse.md)
  - [ServiceErrorResponseDetailsInner](docs/ServiceErrorResponseDetailsInner.md)
  - [TokenAuthenticationMethodDto](docs/TokenAuthenticationMethodDto.md)
  - [TokenDto](docs/TokenDto.md)
  - [TokenList](docs/TokenList.md)
  - [TokenPrivateKeyAuthenticationMethodDto](docs/TokenPrivateKeyAuthenticationMethodDto.md)
  - [TokenPrivateKeyAuthenticationMethodDtoPublicKeyInfo](docs/TokenPrivateKeyAuthenticationMethodDtoPublicKeyInfo.md)
  - [TokenPrivateKeyAuthenticationMethodDtoPublicKeyInfoOneOf](docs/TokenPrivateKeyAuthenticationMethodDtoPublicKeyInfoOneOf.md)
  - [TokenPrivateKeyAuthenticationMethodDtoPublicKeyInfoOneOf1](docs/TokenPrivateKeyAuthenticationMethodDtoPublicKeyInfoOneOf1.md)
  - [TypedPrincipalId](docs/TypedPrincipalId.md)
  - [UnauthorizedError](docs/UnauthorizedError.md)
  - [UnexpectedError](docs/UnexpectedError.md)
  - [UpdateProjectInput](docs/UpdateProjectInput.md)
  - [UpdateTokenInput](docs/UpdateTokenInput.md)
  - [UpdateTokenPrivateKeyAuthenticationMethodDto](docs/UpdateTokenPrivateKeyAuthenticationMethodDto.md)
  - [UserDto](docs/UserDto.md)
  - [UserList](docs/UserList.md)
  - [WhoamiDto](docs/WhoamiDto.md)

  <a id="documentation-for-authorization"></a>



  Authentication schemes defined for the API:
  <a id="HeritageTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="UserTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="ProjectTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="ConsumerTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header



  info@affinidi.com


pkgId: 41238cde9e9875e9906a67f0e9a46ad29e1e1dc17c82393fd25675ddbe33286b
name: python-affinidi_tdk_iota_client-help
arch: noarch
version: 1.32.0
epoch: 0
release: 1
summary: Development documents and examples for affinidi_tdk_iota_client
url: https://github.com/affinidi/affinidi-tdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-affinidi_tdk_iota_client-1.32.0-1.src.rpm
location_href: Packages/python-affinidi_tdk_iota_client-help-1.32.0-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  For more information, please visit [https://github.com/affinidi/affinidi-tdk](https://github.com/affinidi/affinidi-tdk)

  Documentation is available at [https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/iota-framework](https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/iota-framework)



  Python 3.7+





  If the python package is hosted on a repository, you can install directly using:

  ```sh
  pip install affinidi_tdk_iota_client
  ```

  Then import the package:

  ```python
  import affinidi_tdk_iota_client
  ```



  Install via [Setuptools](http://pypi.python.org/pypi/setuptools).

  ```sh
  python setup.py install --user
  ```

  Then import the package:

  ```python
  import affinidi_tdk_iota_client
  ```



  Execute `pytest` to run the tests.



  Please follow the [installation procedure](#installation--usage) and then run the following:

  ```python

  import time
  import affinidi_tdk_iota_client
  from affinidi_tdk_iota_client.rest import ApiException
  from pprint import pprint



  configuration = affinidi_tdk_iota_client.Configuration(
      host = "https://apse1.api.affinidi.io/ais"
  )




  with affinidi_tdk_iota_client.ApiClient(configuration) as api_client:
      
      api_instance = affinidi_tdk_iota_client.CallbackApi(api_client)
      callback_input = affinidi_tdk_iota_client.CallbackInput() # CallbackInput | CallbackRequestInput

      try:
          api_response = api_instance.iot_oidc4_vp_callback(callback_input)
          print("The response of CallbackApi->iot_oidc4_vp_callback:\n")
          pprint(api_response)
      except ApiException as e:
          print("Exception when calling CallbackApi->iot_oidc4_vp_callback: %s\n" % e)

  ```



  All URIs are relative to *https://apse1.api.affinidi.io/ais*

  | Class               | Method                                                                                               | HTTP request                                                               | Description |
  | ------------------- | ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ----------- |
  | _CallbackApi_       | [**iot_oidc4_vp_callback**](docs/CallbackApi.md#iot_oidc4_vp_callback)                               | **POST** /v1/callback                                                      |
  | _ConfigurationsApi_ | [**create_iota_configuration**](docs/ConfigurationsApi.md#create_iota_configuration)                 | **POST** /v1/configurations                                                |
  | _ConfigurationsApi_ | [**delete_iota_configuration_by_id**](docs/ConfigurationsApi.md#delete_iota_configuration_by_id)     | **DELETE** /v1/configurations/{configurationId}                            |
  | _ConfigurationsApi_ | [**get_iota_configuration_by_id**](docs/ConfigurationsApi.md#get_iota_configuration_by_id)           | **GET** /v1/configurations/{configurationId}                               |
  | _ConfigurationsApi_ | [**get_iota_configuration_meta_data**](docs/ConfigurationsApi.md#get_iota_configuration_meta_data)   | **GET** /v1/projects/{projectId}/configurations/{configurationId}/metadata |
  | _ConfigurationsApi_ | [**list_iota_configurations**](docs/ConfigurationsApi.md#list_iota_configurations)                   | **GET** /v1/configurations                                                 |
  | _ConfigurationsApi_ | [**update_iota_configuration_by_id**](docs/ConfigurationsApi.md#update_iota_configuration_by_id)     | **PATCH** /v1/configurations/{configurationId}                             |
  | _DefaultApi_        | [**list_logged_consents**](docs/DefaultApi.md#list_logged_consents)                                  | **GET** /v1/logged-consents                                                |
  | _IotaApi_           | [**aws_exchange_credentials**](docs/IotaApi.md#aws_exchange_credentials)                             | **POST** /v1/aws-exchange-credentials                                      |
  | _IotaApi_           | [**aws_exchange_credentials_project_token**](docs/IotaApi.md#aws_exchange_credentials_project_token) | **POST** /v1/aws-exchange-credentials/project-token                        |
  | _IotaApi_           | [**fetch_iota_vp_response**](docs/IotaApi.md#fetch_iota_vp_response)                                 | **POST** /v1/fetch-iota-response                                           |
  | _IotaApi_           | [**initiate_data_sharing_request**](docs/IotaApi.md#initiate_data_sharing_request)                   | **POST** /v1/initiate-data-sharing-request                                 |
  | _IotaApi_           | [**iota_exchange_credentials**](docs/IotaApi.md#iota_exchange_credentials)                           | **POST** /v1/exchange-credentials                                          |
  | _PexQueryApi_       | [**create_pex_query**](docs/PexQueryApi.md#create_pex_query)                                         | **POST** /v1/configurations/{configurationId}/pex-queries                  |
  | _PexQueryApi_       | [**delete_pex_queries**](docs/PexQueryApi.md#delete_pex_queries)                                     | **POST** /v1/configurations/{configurationId}/delete-queries               |
  | _PexQueryApi_       | [**delete_pex_query_by_id**](docs/PexQueryApi.md#delete_pex_query_by_id)                             | **DELETE** /v1/configurations/{configurationId}/pex-queries/{queryId}      |
  | _PexQueryApi_       | [**get_pex_query_by_id**](docs/PexQueryApi.md#get_pex_query_by_id)                                   | **GET** /v1/configurations/{configurationId}/pex-queries/{queryId}         |
  | _PexQueryApi_       | [**list_pex_queries**](docs/PexQueryApi.md#list_pex_queries)                                         | **GET** /v1/configurations/{configurationId}/pex-queries                   |
  | _PexQueryApi_       | [**save_pex_queries**](docs/PexQueryApi.md#save_pex_queries)                                         | **POST** /v1/configurations/{configurationId}/save-queries                 |
  | _PexQueryApi_       | [**update_pex_query_by_id**](docs/PexQueryApi.md#update_pex_query_by_id)                             | **PATCH** /v1/configurations/{configurationId}/pex-queries/{queryId}       |



  - [AlreadyExistsError](docs/AlreadyExistsError.md)
  - [AwsExchangeCredentials](docs/AwsExchangeCredentials.md)
  - [AwsExchangeCredentialsOK](docs/AwsExchangeCredentialsOK.md)
  - [AwsExchangeCredentialsProjectToken](docs/AwsExchangeCredentialsProjectToken.md)
  - [AwsExchangeCredentialsProjectTokenOK](docs/AwsExchangeCredentialsProjectTokenOK.md)
  - [AwsExchangeCredentialsProjectTokenOKCredentials](docs/AwsExchangeCredentialsProjectTokenOKCredentials.md)
  - [CallbackInput](docs/CallbackInput.md)
  - [CallbackResponseOK](docs/CallbackResponseOK.md)
  - [ConsentDto](docs/ConsentDto.md)
  - [CorsAwsExchangeCredentialsOK](docs/CorsAwsExchangeCredentialsOK.md)
  - [CorsAwsExchangeCredentialsProjectTokenOK](docs/CorsAwsExchangeCredentialsProjectTokenOK.md)
  - [CorsFetchIotaVpResponseOK](docs/CorsFetchIotaVpResponseOK.md)
  - [CorsInitiateDataSharingRequestOK](docs/CorsInitiateDataSharingRequestOK.md)
  - [CorsIotOidc4vpcallbackOK](docs/CorsIotOidc4vpcallbackOK.md)
  - [CorsIotaExchangeCredentialsOK](docs/CorsIotaExchangeCredentialsOK.md)
  - [CreateIotaConfigurationInput](docs/CreateIotaConfigurationInput.md)
  - [CreatePexQueryInput](docs/CreatePexQueryInput.md)
  - [DeletePexQueriesInput](docs/DeletePexQueriesInput.md)
  - [FetchIOTAVPResponseInput](docs/FetchIOTAVPResponseInput.md)
  - [FetchIOTAVPResponseOK](docs/FetchIOTAVPResponseOK.md)
  - [GetIotaConfigurationMetaDataOK](docs/GetIotaConfigurationMetaDataOK.md)
  - [InitiateDataSharingRequestInput](docs/InitiateDataSharingRequestInput.md)
  - [InitiateDataSharingRequestOK](docs/InitiateDataSharingRequestOK.md)
  - [InitiateDataSharingRequestOKData](docs/InitiateDataSharingRequestOKData.md)
  - [InvalidParameterError](docs/InvalidParameterError.md)
  - [InvalidParameterErrorDetailsInner](docs/InvalidParameterErrorDetailsInner.md)
  - [IotaConfigurationDto](docs/IotaConfigurationDto.md)
  - [IotaConfigurationDtoClientMetadata](docs/IotaConfigurationDtoClientMetadata.md)
  - [IotaExchangeCredentials](docs/IotaExchangeCredentials.md)
  - [IotaExchangeCredentialsOK](docs/IotaExchangeCredentialsOK.md)
  - [IotaExchangeCredentialsOKCredentials](docs/IotaExchangeCredentialsOKCredentials.md)
  - [ListConfigurationOK](docs/ListConfigurationOK.md)
  - [ListLoggedConsentsOK](docs/ListLoggedConsentsOK.md)
  - [ListPexQueriesOK](docs/ListPexQueriesOK.md)
  - [MessagePublishingError](docs/MessagePublishingError.md)
  - [NotFoundError](docs/NotFoundError.md)
  - [OperationForbiddenError](docs/OperationForbiddenError.md)
  - [PexQueryDto](docs/PexQueryDto.md)
  - [PrepareRequest](docs/PrepareRequest.md)
  - [PrepareRequestCreated](docs/PrepareRequestCreated.md)
  - [PrepareRequestCreatedData](docs/PrepareRequestCreatedData.md)
  - [ResourceLimitExceededError](docs/ResourceLimitExceededError.md)
  - [SavePexQueriesUpdateInput](docs/SavePexQueriesUpdateInput.md)
  - [SavePexQueriesUpdateInputQueriesInner](docs/SavePexQueriesUpdateInputQueriesInner.md)
  - [UpdateConfigurationByIdInput](docs/UpdateConfigurationByIdInput.md)
  - [UpdateConfigurationByIdOK](docs/UpdateConfigurationByIdOK.md)
  - [UpdatePexQueryInput](docs/UpdatePexQueryInput.md)
  - [VPTokenValidationError](docs/VPTokenValidationError.md)

  <a id="documentation-for-authorization"></a>



  Authentication schemes defined for the API:
  <a id="AwsSigV4"></a>



  - **Type**: API key
  - **API key parameter name**: Authorization
  - **Location**: HTTP header

  <a id="ApiKey"></a>



  - **Type**: API key
  - **API key parameter name**: x-api-key
  - **Location**: HTTP header

  <a id="bearerAuth"></a>



  - **Type**: Bearer authentication (JWT)

  <a id="ConsumerTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="UserTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="ProjectTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header

  <a id="HeritageTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header



  info@affinidi.com


pkgId: d2363f864bf79ff0eec29c819658c20fe31f2eb6b45b2212ca159e98be560b96
name: python-affinidi_tdk_wallets_client-help
arch: noarch
version: 1.33.0
epoch: 0
release: 1
summary: Development documents and examples for affinidi_tdk_wallets_client
url: https://github.com/affinidi/affinidi-tdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-affinidi_tdk_wallets_client-1.33.0-1.src.rpm
location_href: Packages/python-affinidi_tdk_wallets_client-help-1.33.0-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  For more information, please visit [https://github.com/affinidi/affinidi-tdk](https://github.com/affinidi/affinidi-tdk)

  Documentation is available at [https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/wallets](https://docs.affinidi.com/dev-tools/affinidi-tdk/clients/wallets)



  Python 3.7+





  If the python package is hosted on a repository, you can install directly using:

  ```sh
  pip install affinidi_tdk_wallets_client
  ```

  Then import the package:

  ```python
  import affinidi_tdk_wallets_client
  ```



  Install via [Setuptools](http://pypi.python.org/pypi/setuptools).

  ```sh
  python setup.py install --user
  ```

  Then import the package:

  ```python
  import affinidi_tdk_wallets_client
  ```



  Execute `pytest` to run the tests.



  Please follow the [installation procedure](#installation--usage) and then run the following:

  ```python

  import time
  import affinidi_tdk_wallets_client
  from affinidi_tdk_wallets_client.rest import ApiException
  from pprint import pprint



  configuration = affinidi_tdk_wallets_client.Configuration(
      host = "https://apse1.api.affinidi.io/cwe"
  )







  configuration.api_key['ProjectTokenAuth'] = os.environ["API_KEY"]


  import affinidi_tdk_auth_provider

  stats = {
    apiGatewayUrl,
    keyId,
    passphrase,
    privateKey,
    projectId,
    tokenEndpoint,
    tokenId,
  }
  authProvider = affinidi_tdk_auth_provider.AuthProvider(stats)
  configuration.refresh_api_key_hook = lambda api_client: authProvider.fetch_project_scoped_token()






  with affinidi_tdk_wallets_client.ApiClient(configuration) as api_client:
      
      api_instance = affinidi_tdk_wallets_client.RevocationApi(api_client)
      project_id = 'project_id_example' # str | Description for projectId.
      wallet_id = 'wallet_id_example' # str | Description for walletId.
      status_id = 'status_id_example' # str | Description for statusId.

      try:
          api_response = api_instance.get_revocation_credential_status(project_id, wallet_id, status_id)
          print("The response of RevocationApi->get_revocation_credential_status:\n")
          pprint(api_response)
      except ApiException as e:
          print("Exception when calling RevocationApi->get_revocation_credential_status: %s\n" % e)

  ```



  All URIs are relative to *https://apse1.api.affinidi.io/cwe*

  | Class           | Method                                                                                         | HTTP request                                                                       | Description                        |
  | --------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ---------------------------------- |
  | _RevocationApi_ | [**get_revocation_credential_status**](docs/RevocationApi.md#get_revocation_credential_status) | **GET** /v1/projects/{projectId}/wallets/{walletId}/revocation-statuses/{statusId} |
  | _RevocationApi_ | [**get_revocation_list_credential**](docs/RevocationApi.md#get_revocation_list_credential)     | **GET** /v1/wallets/{walletId}/revocation-list/{listId}                            | Return revocation list credential. |
  | _RevocationApi_ | [**revoke_credential**](docs/RevocationApi.md#revoke_credential)                               | **POST** /v1/wallets/{walletId}/revoke                                             | Revoke Credential.                 |
  | _WalletApi_     | [**create_wallet**](docs/WalletApi.md#create_wallet)                                           | **POST** /v1/wallets                                                               |
  | _WalletApi_     | [**delete_wallet**](docs/WalletApi.md#delete_wallet)                                           | **DELETE** /v1/wallets/{walletId}                                                  |
  | _WalletApi_     | [**get_wallet**](docs/WalletApi.md#get_wallet)                                                 | **GET** /v1/wallets/{walletId}                                                     |
  | _WalletApi_     | [**list_wallets**](docs/WalletApi.md#list_wallets)                                             | **GET** /v1/wallets                                                                |
  | _WalletApi_     | [**sign_credential**](docs/WalletApi.md#sign_credential)                                       | **POST** /v1/wallets/{walletId}/sign-credential                                    |
  | _WalletApi_     | [**sign_jwt_token**](docs/WalletApi.md#sign_jwt_token)                                         | **POST** /v1/wallets/{walletId}/sign-jwt                                           |
  | _WalletApi_     | [**update_wallet**](docs/WalletApi.md#update_wallet)                                           | **PATCH** /v1/wallets/{walletId}                                                   |



  - [CreateWalletInput](docs/CreateWalletInput.md)
  - [CreateWalletResponse](docs/CreateWalletResponse.md)
  - [DidKeyInputParams](docs/DidKeyInputParams.md)
  - [DidWebInputParams](docs/DidWebInputParams.md)
  - [EntityNotFoundError](docs/EntityNotFoundError.md)
  - [GetRevocationCredentialStatusOK](docs/GetRevocationCredentialStatusOK.md)
  - [GetRevocationListCredentialResultDto](docs/GetRevocationListCredentialResultDto.md)
  - [InvalidDidParameterError](docs/InvalidDidParameterError.md)
  - [InvalidParameterError](docs/InvalidParameterError.md)
  - [KeyNotFoundError](docs/KeyNotFoundError.md)
  - [NotFoundError](docs/NotFoundError.md)
  - [OperationForbiddenError](docs/OperationForbiddenError.md)
  - [RevokeCredentialInput](docs/RevokeCredentialInput.md)
  - [ServiceErrorResponse](docs/ServiceErrorResponse.md)
  - [ServiceErrorResponseDetailsInner](docs/ServiceErrorResponseDetailsInner.md)
  - [SignCredential400Response](docs/SignCredential400Response.md)
  - [SignCredentialInputDto](docs/SignCredentialInputDto.md)
  - [SignCredentialInputDtoUnsignedCredentialParams](docs/SignCredentialInputDtoUnsignedCredentialParams.md)
  - [SignCredentialResultDto](docs/SignCredentialResultDto.md)
  - [SignCredentialResultDtoSignedCredential](docs/SignCredentialResultDtoSignedCredential.md)
  - [SignJwtToken](docs/SignJwtToken.md)
  - [SignJwtTokenOK](docs/SignJwtTokenOK.md)
  - [SigningFailedError](docs/SigningFailedError.md)
  - [UpdateWalletInput](docs/UpdateWalletInput.md)
  - [WalletDto](docs/WalletDto.md)
  - [WalletDtoKeysInner](docs/WalletDtoKeysInner.md)
  - [WalletsListDto](docs/WalletsListDto.md)

  <a id="documentation-for-authorization"></a>



  Authentication schemes defined for the API:
  <a id="ProjectTokenAuth"></a>



  - **Type**: API key
  - **API key parameter name**: authorization
  - **Location**: HTTP header



  info@affinidi.com


pkgId: 8f4c5b211d0f2c3f051af780259f3a433096f11ca3d34498939817e4d150688b
name: python-agefreighter-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for agefreighter
url: https://github.com/rioriost/agefreighter
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agefreighter-0.5.3-1.src.rpm
location_href: Packages/python-agefreighter-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  a Python package that helps you to create a graph database using Azure Database for PostgreSQL.

  [Apache AGE™](https://age.apache.org/) is a PostgreSQL Graph database compatible with PostgreSQL's distributed assets and leverages graph data structures to analyze and use relationships and patterns in data.

  [Azure Database for PostgreSQL](https://azure.microsoft.com/en-us/services/postgresql/) is a managed database service that is based on the open-source Postgres database engine.

  [Introducing support for Graph data in Azure Database for PostgreSQL (Preview)](https://techcommunity.microsoft.com/blog/adforpostgresql/introducing-support-for-graph-data-in-azure-database-for-postgresql-preview/4275628).


  Refactored the code to make it more readable and maintainable with the separated classes for factory model.
  Please note how to use the new version of the package is tottally different from the previous versions.


  * AzureStorageFreighter class is used to load data from Azure Storage into the graph database. It's totally different from other classes. The class works as follows:
    * If the argument, 'subscription_id' is not set, the class tries to find the Azure Subscription ID from your local environment using the 'az' command.
    * Creates an Azure Storage account and a blob container under the resource group where the PostgreSQL server runs in.
    * Enables the 'azure_storage' extension in the PostgreSQL server, if it's not enabled.
    * Uploads the CSV file to the blob container.
    * Creates a UDF (User Defined Function) named 'load_from_azure_storage' in the PostgreSQL server. The UDF loads data from the Azure Storage into the graph database.
    * Executes the UDF.
  * The above process takes time to prepare for loading data, making it unsuitable for loading small files, but effective for loading large files. For instance, it takes under 3 seconds to load 'actorfilms.csv' after uploading.
  * However, please note that it is still in the early stages of implementation, so there is room for optimization and potential issues due to insufficient testing.


  * AzureStorageFreighter class is totally refactored for better performance and scalability.
    * 0.5.2 didn't work well for large files.
    * Now, it works well for large files.
      Checked with a 5.4GB CSV file consisting of 10M of start vertices, 10K of end vertices, and 25M edges,
      it took 512 seconds to load the data into the graph database with PostgreSQL Flex,
      Standard_D32ds_v4 (32 vcpus, 128 GiB memory) and 512TB / 7500 iops of storage.
    * Tested data was generated with tests/generate_dummy_data.py.
    * UDF to load the data to graph is no longer used.
  * However, please note that it is still in the early stages of implementation, so there is room for optimization and potential issues due to insufficient testing.


  * Asynchronous connection pool support for psycopg PostgreSQL driver
  * 'direct_loading' option for loading data directly into the graph. If 'direct_loading' is True, the data is loaded into the graph using the 'INSERT' statement, not Cypher queries.
  * 'COPY' protocol support for loading data into the graph. If 'use_copy' is True, the data is loaded into the graph using the 'COPY' protocol.


  * AzureStorageFreighter
  * AvroFreighter
  * CosmosGremlinFreighter
  * CSVFreighter
  * MultiCSVFreighter
  * Neo4jFreighter
  * NetworkXFreighter
  * ParquetFreighter
  * PGFreighter


  All the classes have the same load() method. The method loads data into the graph database.


  * common arguments
    * graph_name (str) : the name of the graph
    * chunk_size (int) : the number of rows to be loaded at once
    * direct_loading (bool) : if True, the data is loaded into the graph using the 'INSERT' statement, not Cypher queries
    * use_copy (bool) : if True, the data is loaded into the graph using the 'COPY' protocol
    * drop_graph (bool) : if True, the graph is dropped before loading the data

  * AzureStorageFreighter
    * csv (str): CSV file path
    * start_v_label (str): Start Vertex Label
    * start_id (str): Start Vertex ID
    * start_props (list): Start Vertex Properties
    * edge_type (str): Edge Type
    * end_v_label (str): End Vertex Label
    * end_id (str): End Vertex ID
    * end_props (list): End Vertex Properties
    * graph_name (str): Graph Name
    * chunk_size (int): Chunk Size
    * drop_graph (bool): Drop Graph

  * AvroFreighter
    * source_avro (str): The path to the Avro file.
    * start_v_label (str): The label of the start vertex.
    * start_id (str): The ID of the start vertex.
    * start_props (list): The properties of the start vertex.
    * edge_type (str): The type of the edge.
    * end_v_label (str): The label of the end vertex.
    * end_id (str): The ID of the end vertex.
    * end_props (list): The properties of the end vertex.

  * CosmosGremlinFreighter
    * cosmos_gremlin_endpoint (str): The Cosmos Gremlin endpoint.
    * cosmos_gremlin_key (str): The Cosmos Gremlin key.
    * cosmos_username (str): The Cosmos username.
    * id_map (dict): The ID map.

  * CSVFreighter
    * csv (str): The path to the CSV file.
    * start_v_label (str): The label of the start vertex.
    * start_id (str): The ID of the start vertex.
    * start_props (list): The properties of the start vertex.
    * edge_type (str): The type of the edge.
    * end_v_label (str): The label of the end vertex.
    * end_id (str): The ID of the end vertex.
    * end_props (list): The properties of the end vertex.

  * MultiCSVFreighter
    * vertex_csvs (list): The paths to the vertex CSV files.
    * vertex_labels (list): The labels of the vertices.
    * edge_csvs (list): The paths to the edge CSV files.
    * edge_types (list): The types of the edges.

  * Neo4jFreighter
    * neo4j_uri (str): The URI of the Neo4j database.
    * neo4j_user (str): The username of the Neo4j database.
    * neo4j_password (str): The password of the Neo4j database.
    * neo4j_database (str): The database of the Neo4j database.
    * id_map (dict): The ID map.

  * NetworkXFreighter
    * networkx_graph (nx.Graph): The NetworkX graph.
    * id_map (dict): The ID map.

  * ParquetFreighter
    * source_parquet (str): The path to the Parquet file.
    * start_v_label (str): The label of the start vertex.
    * start_id (str): The ID of the start vertex.
    * start_props (list): The properties of the start vertex.
    * edge_type (str): The type of the edge.
    * end_v_label (str): The label of the end vertex.
    * end_id (str): The ID of the end vertex.
    * end_props (list): The properties of the end vertex.

  * PGFreighter
    * source_pg_con_string (str): The connection string of the source PostgreSQL database.
    * source_schema (str): The source schema.
    * source_tables (list): The source tables.
    * id_map (dict): The ID map.


  * 0.4.0 : Added 'loadFromCosmosGremlin()' function.
  * 0.4.1 : Changed base Python version to 3.9 to run on Azure Cloud Shell and Databricks 15.4ML.
  * 0.4.2 : Tuning for 'loadFromCosmosGremlin()' function.
  * 0.4.3 : Standardized the argument names. Enhanced the tests for each functions.
  * 0.4.4 : Performance tuning.
  * 0.4.5 : Simplified 'loadFromNeo4j'.
  * 0.4.6 : Added 'loadFromAvro()' function.
  * 0.5.0 : Refactored the code to make it more readable and maintainable with the separated classes for factory model. Introduced concurrent.futures for better performance.
  * 0.5.1 : Improved the usage
  * 0.5.2 : Added AzureStorageFreighter class, fixed a bug in ParquetFreighter class (THX! Reported from my co-worker, Srikanth-san)
  * 0.5.3 : Refactored AzureStorageFreighter class for better performance and scalability.



  ```bash
  pip install agefreighter
  ```


  * over Python 3.9
  * This module runs on [psycopg](https://www.psycopg.org/) and [psycopg_pool](https://www.psycopg.org/)
  * Enable the Apache AGE extension in your Azure Database for PostgreSQL instance. Login Azure Portal, go to 'server parameters' blade, and check 'AGE" on within 'azure.extensions' and 'shared_preload_libraries' parameters. See, above blog post for more information.
  * Load the AGE extension in your PostgreSQL database.

  ```sql
  CREATE EXTENSION IF NOT EXISTS age CASCADE;
  ```


  ```python
  import asyncio
  import os
  from agefreighter import Factory
  import logging

  log = logging.getLogger(__name__)
  logging.basicConfig(
      level=logging.DEBUG,
      format="s - s - s - s",
  )


  async def main():
      class_name = "CSVFreighter"
      instance = Factory.create_instance(class_name)

      await instance.connect(
          dsn=os.environ["PG_CONNECTION_STRING"],
          max_connections=64,
      )
      await instance.load(
          graph_name="AgeTester",
          start_v_label="Actor",
          start_id="ActorID",
          start_props=["Actor"],
          edge_type="ACTED_IN",
          end_v_label="Film",
          end_id="FilmID",
          end_props=["Film", "Year", "Votes", "Rating"],
          csv="./actorfilms.csv",
          drop_graph=True,
      )


  if __name__ == "__main__":
      import asyncio

      asyncio.run(main())
  ```

  See, [tests/agefreightertester.py](https://github.com/rioriost/agefreighter/blob/main/tests/agefreightertester.py) for more details.


  ```sql
  export PG_CONNECTION_STRING="host=your_host.postgres.database.azure.com port=5432 dbname=postgres user=account password=your_password"
  cd tests/
  python3.9 agefreightertester.py
  ```


  * Apache AGE : https://age.apache.org/
  * GitHub : https://github.com/apache/age
  * Document : https://age.apache.org/age-manual/master/index.html


  MIT License

rpm_license:
  MIT License  Copyright (c) 2024 Rio Fujita  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: 07d7d8f376acfe444a2764eeaf2295d06c5b56e18d8f0688fe166209269fbbc9
name: python-agefreighter-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for agefreighter
url: https://github.com/rioriost/agefreighter
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agefreighter-0.6.0-1.src.rpm
location_href: Packages/python-agefreighter-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  a Python package that helps you to create a graph database using Azure Database for PostgreSQL.

  [Apache AGE™](https://age.apache.org/) is a PostgreSQL Graph database compatible with PostgreSQL's distributed assets and leverages graph data structures to analyze and use relationships and patterns in data.

  [Azure Database for PostgreSQL](https://azure.microsoft.com/en-us/services/postgresql/) is a managed database service that is based on the open-source Postgres database engine.

  [Introducing support for Graph data in Azure Database for PostgreSQL (Preview)](https://techcommunity.microsoft.com/blog/adforpostgresql/introducing-support-for-graph-data-in-azure-database-for-postgresql-preview/4275628).


  Refactored the code to make it more readable and maintainable with the separated classes for factory model.
  Please note how to use the new version of the package is tottally different from the previous versions.


  * AzureStorageFreighter class is used to load data from Azure Storage into the graph database. It's totally different from other classes. The class works as follows:
    * If the argument, 'subscription_id' is not set, the class tries to find the Azure Subscription ID from your local environment using the 'az' command.
    * Creates an Azure Storage account and a blob container under the resource group where the PostgreSQL server runs in.
    * Enables the 'azure_storage' extension in the PostgreSQL server, if it's not enabled.
    * Uploads the CSV file to the blob container.
    * Creates a UDF (User Defined Function) named 'load_from_azure_storage' in the PostgreSQL server. The UDF loads data from the Azure Storage into the graph database.
    * Executes the UDF.
  * The above process takes time to prepare for loading data, making it unsuitable for loading small files, but effective for loading large files. For instance, it takes under 3 seconds to load 'actorfilms.csv' after uploading.
  * However, please note that it is still in the early stages of implementation, so there is room for optimization and potential issues due to insufficient testing.


  * AzureStorageFreighter class is totally refactored for better performance and scalability.
    * 0.5.2 didn't work well for large files.
    * Now, it works well for large files.
      Checked with a 5.4GB CSV file consisting of 10M of start vertices, 10K of end vertices, and 25M edges,
      it took 512 seconds to load the data into the graph database with PostgreSQL Flex,
      Standard_D32ds_v4 (32 vcpus, 128 GiB memory) and 512TB / 7500 iops of storage.
    * Tested data was generated with tests/generate_dummy_data.py.
    * UDF to load the data to graph is no longer used.
  * However, please note that it is still in the early stages of implementation, so there is room for optimization and potential issues due to insufficient testing.


  * Added edge properties support.
    * 'edge_props' argument (list) is added to the 'load()' method.
  * 'drop_graph' argument is obsoleted. 'create_graph' argument is added.
    * 'create_graph' is set to True by default. CAUTION: If the graph already exists, the graph is dropped before loading the data.
    * If 'create_graph' is False, the data is loaded into the existing graph.


  * Asynchronous connection pool support for psycopg PostgreSQL driver
  * 'direct_loading' option for loading data directly into the graph. If 'direct_loading' is True, the data is loaded into the graph using the 'INSERT' statement, not Cypher queries.
  * 'COPY' protocol support for loading data into the graph. If 'use_copy' is True, the data is loaded into the graph using the 'COPY' protocol.


  * AzureStorageFreighter
  * AvroFreighter
  * CosmosGremlinFreighter
  * CSVFreighter
  * MultiCSVFreighter
  * Neo4jFreighter
  * NetworkXFreighter
  * ParquetFreighter
  * PGFreighter


  All the classes have the same load() method. The method loads data into the graph database.


  * Common arguments
    * graph_name (str) : the name of the graph
    * chunk_size (int) : the number of rows to be loaded at once
    * direct_loading (bool) : if True, the data is loaded into the graph using the 'INSERT' statement, not Cypher queries
    * use_copy (bool) : if True, the data is loaded into the graph using the 'COPY' protocol
    * create_graph (bool) : if True, the graph will be created after the existing graph is dropped

  * Common arguments for 'Single Source' classes
    * AvroFreighter
    * AzureStorageFreighter
    * CosmosGremlinFreighter
    * Neo4jFreighter
    * NetworkXFreighter
    * ParquetFreighter
    * PGFreighter
      * start_v_label (str): Start Vertex Label
      * start_id (str): Start Vertex ID
      * start_props (list): Start Vertex Properties
      * edge_type (str): Edge Type
      * edge_props (list): Edge Properties
      * end_v_label (str): End Vertex Label
      * end_id (str): End Vertex ID
      * end_props (list): End Vertex Properties

  * Class specific arguments
    * AvroFreighter
      * source_avro (str): The path to the Avro file.

    * CosmosGremlinFreighter
      * cosmos_gremlin_endpoint (str): The Cosmos Gremlin endpoint.
      * cosmos_gremlin_key (str): The Cosmos Gremlin key.
      * cosmos_username (str): The Cosmos username.
      * id_map (dict): ID Mapping

    * MultiCSVFreighter
      * vertex_csvs (list): The paths to the vertex CSV files.
      * vertex_labels (list): The labels of the vertices.
      * edge_csvs (list): The paths to the edge CSV files.
      * edge_types (list): The types of the edges.

    * Neo4jFreighter
      * neo4j_uri (str): The URI of the Neo4j database.
      * neo4j_user (str): The username of the Neo4j database.
      * neo4j_password (str): The password of the Neo4j database.
      * neo4j_database (str): The database of the Neo4j database.
      * id_map (dict): ID Mapping

    * NetworkXFreighter
      * networkx_graph (nx.Graph): The NetworkX graph.
      * id_map (dict): ID Mapping

    * ParquetFreighter
      * source_parquet (str): The path to the Parquet file.

    * PGFreighter
      * source_pg_con_string (str): The connection string of the source PostgreSQL database.
      * source_schema (str): The source schema.
      * source_tables (list): The source tables.
      * id_map (dict): ID Mapping



  * 0.4.0 : Added 'loadFromCosmosGremlin()' function.
  * 0.4.1 : Changed base Python version to 3.9 to run on Azure Cloud Shell and Databricks 15.4ML.
  * 0.4.2 : Tuning for 'loadFromCosmosGremlin()' function.
  * 0.4.3 : Standardized the argument names. Enhanced the tests for each functions.
  * 0.4.4 : Performance tuning.
  * 0.4.5 : Simplified 'loadFromNeo4j'.
  * 0.4.6 : Added 'loadFromAvro()' function.
  * 0.5.0 : Refactored the code to make it more readable and maintainable with the separated classes for factory model. Introduced concurrent.futures for better performance.
  * 0.5.1 : Improved the usage
  * 0.5.2 : Added AzureStorageFreighter class, fixed a bug in ParquetFreighter class (THX! Reported from my co-worker, Srikanth-san)
  * 0.5.3 : Refactored AzureStorageFreighter class for better performance and scalability.
  * 0.6.0 : Added edge properties support. 'drop_graph' argument is obsoleted. 'create_graph' argument is added.



  ```bash
  pip install agefreighter
  ```


  * over Python 3.9
  * This module runs on [psycopg](https://www.psycopg.org/) and [psycopg_pool](https://www.psycopg.org/)
  * Enable the Apache AGE extension in your Azure Database for PostgreSQL instance. Login Azure Portal, go to 'server parameters' blade, and check 'AGE" on within 'azure.extensions' and 'shared_preload_libraries' parameters. See, above blog post for more information.
  * Load the AGE extension in your PostgreSQL database.

  ```sql
  CREATE EXTENSION IF NOT EXISTS age CASCADE;
  ```


  ```python
  import asyncio
  import os
  from agefreighter import Factory
  import logging

  log = logging.getLogger(__name__)
  logging.basicConfig(
      level=logging.DEBUG,
      format="s - s - s - s",
  )


  async def main():
      class_name = "CSVFreighter"
      instance = Factory.create_instance(class_name)

      await instance.connect(
          dsn=os.environ["PG_CONNECTION_STRING"],
          max_connections=64,
      )
      await instance.load(
          graph_name="AgeTester",
          start_v_label="Actor",
          start_id="ActorID",
          start_props=["Actor"],
          edge_type="ACTED_IN",
          edge_props=["Role", "Director"],
          end_v_label="Film",
          end_id="FilmID",
          end_props=["Film", "Year", "Votes", "Rating"],
          csv="./actorfilms.csv",
          drop_graph=True,
      )


  if __name__ == "__main__":
      import asyncio

      asyncio.run(main())
  ```

  See, [tests/agefreightertester.py](https://github.com/rioriost/agefreighter/blob/main/tests/agefreightertester.py) for more details.


  ```sql
  export PG_CONNECTION_STRING="host=your_host.postgres.database.azure.com port=5432 dbname=postgres user=account password=your_password"
  cd tests/
  python3.9 agefreightertester.py
  ```


  * Apache AGE : https://age.apache.org/
  * GitHub : https://github.com/apache/age
  * Document : https://age.apache.org/age-manual/master/index.html


  MIT License

rpm_license:
  MIT License  Copyright (c) 2024 Rio Fujita  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: c1b1e3f267672b0296a5c31b908fe44fb1a7c58a317b78d6cec5dd0029e4d090
name: python-agency-swarm-help
arch: noarch
version: 0.4.2
epoch: 0
release: 1
summary: Development documents and examples for agency-swarm
url: https://github.com/VRSEN/agency-swarm
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agency-swarm-0.4.2-1.src.rpm
location_href: Packages/python-agency-swarm-help-0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Framework](https://firebasestorage.googleapis.com/v0/b/vrsen-ai/o/public%2Fgithub%2Fagency-swarm-logo-white.png?alt=media&token=76d8615d-1211-426a-bd4f-b9098cbfbc43)



  Agency Swarm started as a desire and effort of Arsenii Shatokhin (aka VRSEN) to fully automate his AI Agency with AI. By building this framework, we aim to simplify the agent creation process and enable anyone to create collaborative swarm of agents (Agencies), each with distinct roles and capabilities. By thinking about automation in terms of real world entities, such as agencies and specialized agent roles, we make it a lot more intuitive for both the agents and the users.

  [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1qGVyK-vIoxZD0dMrMVqCxCsgL1euMLKj)
  [![Docs](https://img.shields.io/website?label=Docs&up_message=available&url=https://vrsen.github.io/agency-swarm/)](https://vrsen.github.io/agency-swarm/)
  [![Subscribe on YouTube](https://img.shields.io/youtube/channel/subscribers/UCSv4qL8vmoSH7GaPjuqRiCQ
  )](https://youtube.com/@vrsen/)
  [![Follow on Twitter](https://img.shields.io/twitter/follow/__vrsen__.svg?style=social&label=Follow%20%40__vrsen__)](https://twitter.com/__vrsen__)
  [![Join our Discord!](https://img.shields.io/discord/1200037936352202802?label=Discord)](https://discord.gg/cw2xBaWfFM)
  [![Agents-as-a-Service](https://img.shields.io/website?label=Agents-as-a-Service&up_message=For%20Business&url=https%3A%2F%2Fvrsen.ai)](https://agents.vrsen.ai)



  - **Customizable Agent Roles**: Define roles like CEO, virtual assistant, developer, etc., and customize their functionalities with [Assistants API](https://platform.openai.com/docs/assistants/overview).
  - **Full Control Over Prompts**: Avoid conflicts and restrictions of pre-defined prompts, allowing full customization.
  - **Tool Creation**: Tools within Agency Swarm are created using [Instructor](https://github.com/jxnl/instructor), which provides a convenient interface and automatic type validation.
  - **Efficient Communication**: Agents communicate through a specially designed "send message" tool based on their own descriptions.
  - **State Management**: Agency Swarm efficiently manages the state of your assistants on OpenAI, maintaining it in a special `settings.json` file.
  - **Deployable in Production**: Agency Swarm is designed to be reliable and easily deployable in production environments.




  ```bash
  pip install -U agency-swarm
  ```




  1. **Set Your OpenAI Key**:

      ```python
      from agency_swarm import set_openai_key
      set_openai_key("YOUR_API_KEY")
      ```

  2. **Create Tools**:
  Define your custom tools with [Instructor](https://github.com/jxnl/instructor):
      ```python
      from agency_swarm.tools import BaseTool
      from pydantic import Field

      class MyCustomTool(BaseTool):
          """
          A brief description of what the custom tool does.
          The docstring should clearly explain the tool's purpose and functionality.
          """

          
          example_field: str = Field(
              ..., description="Description of the example field, explaining its purpose and usage."
          )

          
          

          def run(self):
              """
              The implementation of the run method, where the tool's main functionality is executed.
              This method should utilize the fields defined above to perform its task.
              Doc string description is not required for this method.
              """

              
              do_something(self.example_field)

              
              return "Result of MyCustomTool operation"
      ```

      or convert from OpenAPI schemas:

      ```python
      from agency_swarm.tools import ToolFactory
      
      with open("schemas/your_schema.json") as f:
          tools = ToolFactory.from_openapi_schema(
              f.read(),
          )

      
      tools = ToolFactory.from_openapi_schema(
          requests.get("https://api.example.com/openapi.json").json(),
      )
      ```

  3. **Define Agent Roles**: Start by defining the roles of your agents. For example, a CEO agent for managing tasks and a developer agent for executing tasks.

      ```python
      from agency_swarm import Agent

      ceo = Agent(name="CEO",
                  description="Responsible for client communication, task planning and management.",
                  instructions="You must converse with other agents to ensure complete task execution.", # can be a file like ./instructions.md
                  files_folder="./files", # files to be uploaded to OpenAI
                  schemas_folder="./schemas", # OpenAPI schemas to be converted into tools
                  tools=[MyCustomTool],
                  temperature=0.5, # temperature for the agent
                  max_prompt_tokens=25000, # max tokens in conversation history
                  )
      ```

      Import from existing agents:

     ```bash
     agency-swarm import-agent --name "Devid" --destination "./"
     ```

     This will import Devid (Software Developer) Agent locally, including all source code files, so you have full control over your system. Currently, available agents are: `Devid`, `BrowsingAgent`.



  4. **Define Agency Communication Flows**:
  Establish how your agents will communicate with each other.

      ```python
      from agency_swarm import Agency
      
      from Developer import Developer
      from VirtualAssistant import VirtualAssistant

      dev = Developer()
      va = VirtualAssistant()

      agency = Agency([
             ceo,  # CEO will be the entry point for communication with the user
             [ceo, dev],  # CEO can initiate communication with Developer
             [ceo, va],   # CEO can initiate communication with Virtual Assistant
             [dev, va]    # Developer can initiate communication with Virtual Assistant
           ],
           shared_instructions='agency_manifesto.md', #shared instructions for all agents
           temperature=0.5, # default temperature for all agents
           max_prompt_tokens=25000 # default max tokens in conversation history
      )
      ```

       In Agency Swarm, communication flows are directional, meaning they are established from left to right in the agency_chart definition. For instance, in the example above, the CEO can initiate a chat with the developer (dev), and the developer can respond in this chat. However, the developer cannot initiate a chat with the CEO. The developer can initiate a chat with the virtual assistant (va) and assign new tasks.

  5. **Run Demo**:
  Run the demo to see your agents in action!

      Web interface:

      ```python
      agency.demo_gradio(height=900)
      ```

      Terminal version:

      ```python
      agency.run_demo()
      ```

      Backend version:

      ```python
      completion_output = agency.get_completion("Please create a new website for our client.")
      ```





  The `genesis` command starts the genesis agency in your terminal to help you create new agencies and agents.



  ```bash
  agency-swarm genesis [--openai_key "YOUR_API_KEY"]
  ```

  Make sure to include:
  - Your mission and goals.
  - The agents you want to involve and their communication flows.
  - Which tools or APIs each agent should have access to, if any.



  This CLI command allows you to import existing agents from local files into your agency.



  ```bash
  agency-swarm import-agent --name "AgentName" --destination "/path/to/directory"
  ```

  To check available agents, simply run this command without any arguments.



  This CLI command simplifies the process of creating a structured environment for each agent.



  ```bash
  agency-swarm create-agent-template --name "AgentName" --description "Agent Description" [--path "/path/to/directory"] [--use_txt]
  ```



  When you run the `create-agent-template` command, it creates the following folder structure for your agent:

  ```
  /your-specified-path/
  │
  ├── agency_manifesto.md or .txt # Agency's guiding principles (created if not exists)
  └── AgentName/                  # Directory for the specific agent
      ├── files/                  # Directory for files that will be uploaded to openai
      ├── schemas/                # Directory for OpenAPI schemas to be converted into tools
      ├── tools/                  # Directory for tools to be imported by default.
      ├── AgentName.py            # The main agent class file
      ├── __init__.py             # Initializes the agent folder as a Python package
      ├── instructions.md or .txt # Instruction document for the agent
      └── tools.py                # Custom tools specific to the agent

  ```

  This structure ensures that each agent has its dedicated space with all necessary files to start working on its specific tasks. The `tools.py` can be customized to include tools and functionalities specific to the agent's role.



  1. [x] Creation of agencies that can autonomously create other agencies.
  2. [x] Asynchronous communication and task handling.
  3. [ ] Inter-agency communication for a self-expanding system.



  For details on how to contribute you agents and tools to Agency Swarm, please refer to the [Contributing Guide](CONTRIBUTING.md).



  Agency Swarm is open-source and licensed under [MIT](https://opensource.org/licenses/MIT).





  If you need help creating custom agent swarms for your business, check out our [Agents-as-a-Service](https://agents.vrsen.ai/) subscription, or schedule a consultation with me at https://calendly.com/vrsen/ai-project-consultation

rpm_license:
  MIT License  Copyright (c) 2023 Arsenii Shatokhin  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: 6ca5d50cc7b5bd72d9ab5ceb2f6ffb109b0bafd234f8db8d4809c2f4f35e4586
name: python-agentCores-help
arch: noarch
version: 0.1.27
epoch: 0
release: 1
summary: Development documents and examples for agentCores
url: https://github.com/Leoleojames1/agentCores
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agentCores-0.1.27-1.src.rpm
location_href: Packages/python-agentCores-help-0.1.27-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/Leoleojames1/agentCores/main/src/agentCores/data/agentCoresLogoFix.png" alt="agentCores logo" width="450"/>
  </p>



  agentCores is a powerful MongoDB-based system for creating, managing, and deploying AI agents. It provides a comprehensive framework for handling complex agent configurations, making it easier to work with multiple AI models and agent types.



  1. **Agent Configuration Management**:
     - Create, store, and manage AI agent configurations in MongoDB
     - Version control and unique identifiers for each agent
     - Template-based agent creation with extensive customization

  2. **Database Integration**:
     - MongoDB collections for agent data, conversations, and knowledge
     - Customizable collection structures and configurations
     - Built-in database management and optimization

  3. **Model and Prompt Management**:
     - Support for multiple AI models (language, vision, speech)
     - Structured prompt templates and version control
     - Integration with Ollama and other model providers

  4. **Research and Development Tools**:
     - Built-in research assistant capabilities
     - Paper and code repository integration
     - Knowledge base management

  5. **Command-line Interface**:
     - Interactive agent management
     - Real-time chat capabilities
     - Database administration tools



  ```bash
  pip install agentCores
  ```


  - Python 3.8+
  - MongoDB
  - ollama (optional, for LLM functionality)
  - duckduckgo_search (optional, for research capabilities)



  agentCores uses a single MongoDB database named `agentCores` with organized collections:

  ```
  MongoDB Database: agentCores/
  ├── System Collections:
  │   ├── agent_matrix         # Main agent configurations
  │   ├── documentation        # System documentation
  │   ├── templates           # Agent templates
  │   └── template_files      # Template resources
  ├── Agent-Specific Collections:
  │   ├── conversations_{agent_id}    # Chat history
  │   ├── knowledge_{agent_id}        # Knowledge base
  │   ├── embeddings_{agent_id}       # Vector embeddings
  │   ├── research_{agent_id}         # Research data
  │   └── design_patterns_{agent_id}  # Agent patterns
  └── Shared Collections:
      ├── global_knowledge     # Shared knowledge base
      ├── model_configs       # Model configurations
      └── prompt_templates    # Prompt templates
  ```





  ```python
  from agentCores import agentCores


  core = agentCores()


  core = agentCores(connection_uri="mongodb://localhost:27017/")


  agent = core.mintAgent(
      agent_id="my_assistant",
      model_config={
          "largeLanguageModel": {
              "names": ["llama2"],
              "instances": None,
              "concurrency": [],
              "parrallelModels": None
          }
      },
      prompt_config={
          "userInput": "You are a helpful assistant",
          "agent": {
              "llmSystem": "Provide clear and concise answers",
              "llmBooster": "Use examples when helpful"
          }
      }
  )


  core.chat_with_agent("my_assistant")
  ```



  ```python
  from agentCores import researchAssistant


  assistant = researchAssistant(
      agent_id="research_agent",
      connection_uri="mongodb://localhost:27017/"
  )


  response = assistant.process_query("What is quantum computing?")


  assistant.start_chat()
  ```





  ```python
  {
      "agentCore": {
          "identifyers": {
              "agent_id": str,          # Unique identifier
              "uid": str,               # Generated hash
              "version": int,           # Version number
              "creationDate": float,    # Creation timestamp
              "cpuNoiseHex": str        # Hardware identifier
          },
          "models": {
              "largeLanguageModel": {
                  "names": list,         # Model names
                  "instances": None,     # Instance count
                  "concurrency": list,   # Concurrency settings
                  "parrallelModels": None,
                  "model_config_template": dict
              },
              "largeLanguageAndVisionAssistant": dict,
              "yoloVision": dict,
              "speechRecognitionSTT": dict,
              "voiceGenerationTTS": dict,
              "embedding": dict
          },
          "prompts": {
              "userInput": str,
              "agent": {
                  "llmSystem": str,
                  "llmBooster": str,
                  "visionSystem": str,
                  "visionBooster": str
              }
          },
          "modalityFlags": {
              "TTS_FLAG": bool,         # Text-to-speech
              "STT_FLAG": bool,         # Speech-to-text
              "CHUNK_AUDIO_FLAG": bool,
              "AUTO_SPEECH_FLAG": bool,
              "LLAVA_FLAG": bool,
              "SCREEN_SHOT_FLAG": bool,
              "SPLICE_VIDEO_FLAG": bool,
              "AUTO_COMMANDS_FLAG": bool,
              "CLEAR_MEMORY_FLAG": bool,
              "ACTIVE_AGENT_FLAG": bool
          },
          "evolutionarySettings": {
              "mutation": float,
              "pain": float,
              "hunger": float,
              "fasting": bool,
              "rationalizationFactor": float
          }
      }
  }
  ```



  Start the interface:
  ```bash
  python -m agentCores
  ```

  Available commands:
  ```
  /help                         Show available commands
  /agentCores                   List all agent cores
  /showAgent <agent_id>         Show agent configuration
  /createAgent <template_id> <new_agent_id>   Create new agent
  /createCustomAgent            Interactive agent creation
  /createCollection <name>      Create MongoDB collection
  /linkCollection <agent_id> <collection_name>  Link collection to agent
  /storeAgent <file_path>       Import agent from JSON
  /exportAgent <agent_id>       Export agent to JSON
  /deleteAgent <agent_id>       Delete an agent
  /resetAgent <agent_id>        Reset agent to base template
  /chat <agent_id>             Start chat session
  /knowledge <agent_id>         View knowledge base
  /conversations <agent_id>     View conversation history
  ```





  ```python
  model_config = {
      "largeLanguageModel": {
          "instances": 2,
          "names": ["llama2", "codellama"],
          "concurrency": ["parallel", "sequential"],
          "parrallelModels": True,
          "model_config_template": {
              "temperature": 0.7,
              "context_window": 4096,
              "streaming": True
          }
      }
  }

  agent = core.mintAgent(
      agent_id="advanced_agent",
      model_config=model_config
  )
  ```



  ```python

  core.create_collection_with_schema(
      "research_papers",
      indexes=[
          [("paper_id", 1)],
          [("title", "text")]
      ]
  )


  core.linkDatabase(
      "research_agent",
      "research_papers"
  )
  ```



  ```python
  from agentCores import researchAssistant


  assistant = researchAssistant(
      agent_id="research_agent",
      connection_uri="mongodb://localhost:27017/"
  )


  assistant.core.create_collection_with_schema(
      "papers",
      indexes=[
          [("paper_id", 1)],
          [("title", "text")]
      ]
  )


  results = assistant.search("quantum computing")
  response = assistant.process_query(
      "Explain recent advances in quantum computing"
  )
  ```





  ```python

  core.create_collection_with_schema(
      "research_papers",
      indexes=[
          [("paper_id", 1)],
          [("title", "text")]
      ]
  )


  results = core.execute_query(
      "research_papers",
      {"title": {"$regex": "neural networks", "$options": "i"}}
  )


  core.bulk_insert(
      "research_papers",
      documents=[...]
  )
  ```



  ```python

  template_id = core.register_template(
      "research_template",
      template_data={...},
      metadata={"version": "1.0"}
  )


  template = core.get_template("research_template")


  templates = core.list_templates()
  ```



  1. **Database Management**
     - Use descriptive collection names
     - Implement proper MongoDB indexes
     - Regular maintenance of collections
     - Back up important data

  2. **Agent Creation**
     - Start with templates
     - Version control configurations
     - Document custom settings
     - Test before deployment

  3. **Error Handling**
     - Implement proper exception handling
     - Log errors and warnings
     - Include recovery strategies
     - Monitor agent performance



  1. Fork the repository
  2. Create a feature branch
  3. Follow PEP 8 style guide
  4. Add tests for new features
  5. Update documentation
  6. Submit pull request



  MIT License - see LICENSE file for details



  Leo Borcherding



  - GitHub: https://github.com/Leoleojames1/agentCores
  - Documentation: https://agentcore.readthedocs.io/
  - Issues: https://github.com/Leoleojames1/agentCores/issues



  0.1.27 (2024-12-11)

rpm_license:
  MIT License  Copyright (c) 2024 Borch  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: e36464d8954d95cfab6fb75e0a76f3680f1d374ca4e06f25abcaa1d9b9760763
name: python-agenta-help
arch: noarch
version: 0.29.0
epoch: 0
release: 1
summary: Development documents and examples for agenta
url: https://agenta.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agenta-0.29.0-1.src.rpm
location_href: Packages/python-agenta-help-0.29.0-1.noarch.rpm
checksum_type: sha256
description:
  <h3 align="center">
    <a href="https://docs.agenta.ai?utm_source=github&utm_medium=referral&utm_campaign=readme"><b>Documentation</b></a> &bull;
    <a href="https://docs.agenta.ai/changelog/main?utm_source=github&utm_medium=referral&utm_campaign=readme"><b>Changelog</b></a> &bull;
    <a href="https://agenta.ai?utm_source=github&utm_medium=referral&utm_campaign=readme"><b>Website</b></a> &bull;
    <a href="https://cloud.agenta.ai?utm_source=github&utm_medium=referral&utm_campaign=readme"><b>Agenta Cloud</b></a>


pkgId: 0a2e2be8a240f0f0ff4aab9b95266d16d5fb6e2dc017187c8c47cc7d0bda89f0
name: python-agentic_security-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for agentic_security
url: https://github.com/msoedov/agentic_security
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agentic_security-0.3.4-1.src.rpm
location_href: Packages/python-agentic_security-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">

  <h1 align="center">Agentic Security</h1>

  <p align="center">
      The open-source Agentic LLM Vulnerability Scanner
      <br />
      <br />

  <p>
  <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/msoedov/agentic_security" />
  <img alt="GitHub Last Commit" src="https://img.shields.io/github/last-commit/msoedov/agentic_security" />
  <img alt="" src="https://img.shields.io/github/repo-size/msoedov/agentic_security" />
  <img alt="Downloads" src="https://static.pepy.tech/badge/agentic_security" />
  <img alt="GitHub Issues" src="https://img.shields.io/github/issues/msoedov/agentic_security" />
  <img alt="GitHub Pull Requests" src="https://img.shields.io/github/issues-pr/msoedov/agentic_security" />
  <img alt="Github License" src="https://img.shields.io/github/license/msoedov/agentic_security" />
  </p>
    </p>
  </p>



  - Customizable Rule Sets or Agent based attacks🛠️
  - Comprehensive fuzzing for any LLMs 🧪
  - LLM API integration and stress testing 🛠️
  - Wide range of fuzzing and attack techniques 🌀

  Note: Please be aware that Agentic Security is designed as a safety scanner tool and not a foolproof solution. It cannot guarantee complete protection against all possible threats.



  To get started with Agentic Security, simply install the package using pip:

  ```shell
  pip install agentic_security
  ```



  ```shell
  agentic_security

  2024-04-13 13:21:31.157 | INFO     | agentic_security.probe_data.data:load_local_csv:273 - Found 1 CSV files
  2024-04-13 13:21:31.157 | INFO     | agentic_security.probe_data.data:load_local_csv:274 - CSV files: ['prompts.csv']
  INFO:     Started server process [18524]
  INFO:     Waiting for application startup.
  INFO:     Application startup complete.
  INFO:     Uvicorn running on http://0.0.0.0:8718 (Press CTRL+C to quit)
  ```

  ```shell
  python -m agentic_security

  agentic_security --help


  agentic_security --port=PORT --host=HOST

  ```



  <img width="100%" alt="booking-screen" src="https://res.cloudinary.com/do9qa2bqr/image/upload/v1713002396/1-ezgif.com-video-to-gif-converter_s2hsro.gif">



  Agentic Security uses plain text HTTP spec like:

  ```http
  POST https://api.openai.com/v1/chat/completions
  Authorization: Bearer sk-xxxxxxxxx
  Content-Type: application/json

  {
       "model": "gpt-3.5-turbo",
       "messages": [{"role": "user", "content": "<<PROMPT>>"}],
       "temperature": 0.7
  }

  ```

  Where `<<PROMPT>>` will be replaced with the actual attack vector during the scan, insert the `Bearer XXXXX` header value with your app credentials.



  TBD

  ```
  ....
  ```



  To add your own dataset you can place one or multiples csv files with `prompt` column, this data will be loaded on `agentic_security` startup

  ```
  2024-04-13 13:21:31.157 | INFO     | agentic_security.probe_data.data:load_local_csv:273 - Found 1 CSV files
  2024-04-13 13:21:31.157 | INFO     | agentic_security.probe_data.data:load_local_csv:274 - CSV files: ['prompts.csv']
  ```



  ci.py

  ```python
  from agentic_security import AgenticSecurity

  spec = """
  POST http://0.0.0.0:8718/v1/self-probe
  Authorization: Bearer XXXXX
  Content-Type: application/json

  {
      "prompt": "<<PROMPT>>"
  }
  """
  result = AgenticSecurity.scan(llmSpec=spec)



  exit(max(r.values()) > 20)
  ```

  ```
  python ci.py
  2024-04-27 17:15:13.545 | INFO     | agentic_security.probe_data.data:load_local_csv:279 - Found 1 CSV files
  2024-04-27 17:15:13.545 | INFO     | agentic_security.probe_data.data:load_local_csv:280 - CSV files: ['prompts.csv']
  0it [00:00, ?it/s][INFO] 2024-04-27 17:15:13.74 | data:prepare_prompts:195 | Loading Custom CSV
  [INFO] 2024-04-27 17:15:13.74 | fuzzer:perform_scan:53 | Scanning Local CSV 15
  18it [00:00, 176.88it/s]
  +-----------+--------------+--------+
  |  Module   | Failure Rate | Status |
  +-----------+--------------+--------+
  | Local CSV |    80.0%     |   ✘    |
  +-----------+--------------+--------+
  ```



  1. Add new metadata to agentic_security.probe_data.REGISTRY

  ```python
      {
          "dataset_name": "markush1/LLM-Jailbreak-Classifier",
          "num_prompts": 1119,
          "tokens": 19758,
          "approx_cost": 0.0,
          "source": "Hugging Face Datasets",
          "selected": True,
          "dynamic": False,
          "url": "https://huggingface.co/markush1/LLM-Jailbreak-Classifier",
      },
  ```

  and implement loader into

  ```python
  @dataclass
  class ProbeDataset:
      dataset_name: str
      metadata: dict
      prompts: list[str]
      tokens: int
      approx_cost: float

      def metadata_summary(self):
          return {
              "dataset_name": self.dataset_name,
              "num_prompts": len(self.prompts),
              "tokens": self.tokens,
              "approx_cost": self.approx_cost,
          }

  ```



  One of the current examples uses sampling for the existing preloaded prompt data and applying mutations yielding a new dataset

  ```python
  class Stenography:
      fn_library = {
          "rot5": stenography_fn.rot5,
          "rot13": stenography_fn.rot13,
          "base64": stenography_fn.base64_encode,
          "mirror": stenography_fn.mirror_words,
          "random_case": stenography_fn.randomize_letter_case,
          "scramble_words": stenography_fn.scramble_words,
          "noise_characters": stenography_fn.insert_noise_characters,
          "substitute_with_ascii": stenography_fn.substitute_with_ascii,
          "remove_vowels": stenography_fn.remove_vowels,
          "zigzag_obfuscation": stenography_fn.zigzag_obfuscation,
      }

      def __init__(self, prompt_groups: [ProbeDataset]):
          self.prompt_groups = prompt_groups

      def apply(self):
          for prompt_group in self.prompt_groups:

              size = len(prompt_group.prompts)
              for name, fn in self.fn_library.items():
                  logger.info(f"Applying {name} to {prompt_group.dataset_name}")
                  selected_prompts = random.sample(prompt_group.prompts, int(size * 0.25))
                  prompts = [
                      f"Follow the instructions in {name}: {fn(p)}"
                      for p in selected_prompts
                  ]
                  yield ProbeDataset(
                      dataset_name=f"stenography.{name}({prompt_group.dataset_name})",
                      metadata={},
                      prompts=prompts,
                      tokens=count_words_in_list(prompts),
                      approx_cost=0.0,
                  )
  ```



  In the example of custom integration, we use `/v1/self-probe` for the sake of integration testing.

  ```python
  POST https://agentic_security-preview.vercel.app/v1/self-probe
  Authorization: Bearer XXXXX
  Content-Type: application/json

  {
      "prompt": "<<PROMPT>>"
  }

  ```

  This endpoint randomly mimics the refusal of a fake LLM.

  ```python
  @app.post("/v1/self-probe")
  def self_probe(probe: Probe):
      refuse = random.random() < 0.2
      message = random.choice(REFUSAL_MARKS) if refuse else "This is a test!"
      message = probe.prompt + " " + message
      return {
          "id": "chatcmpl-abc123",
          "object": "chat.completion",
          "created": 1677858242,
          "model": "gpt-3.5-turbo-0613",
          "usage": {"prompt_tokens": 13, "completion_tokens": 7, "total_tokens": 20},
          "choices": [
              {
                  "message": {"role": "assistant", "content": message},
                  "logprobs": None,
                  "finish_reason": "stop",
                  "index": 0,
              }
          ],
      }

  ```



  TBD



  For more detailed information on how to use Agentic Security, including advanced features and customization options, please refer to the official documentation.



  - \[ \] Expand dataset variety
  - \[ \] Introduce two new attack vectors
  - \[ \] Develop initial attacker LLM
  - \[ \] Complete integration of OWASP Top 10 classification

  | Tool                    | Source                                                                        | Integrated |
  |-------------------------|-------------------------------------------------------------------------------|------------|
  | Garak                   | [leondz/garak](https://github.com/leondz/garak)                               | ✅          |
  | InspectAI               | [UKGovernmentBEIS/inspect_ai](https://github.com/UKGovernmentBEIS/inspect_ai) | ✅          |
  | llm-adaptive-attacks    | [tml-epfl/llm-adaptive-attacks](https://github.com/tml-epfl/llm-adaptive-attacks) | ✅       |
  | Custom Huggingface Datasets | markush1/LLM-Jailbreak-Classifier                                                                         | ✅          |
  | Local CSV Datasets      | -                                                                             | ✅          |

  Note: All dates are tentative and subject to change based on project progress and priorities.



  Contributions to Agentic Security are welcome! If you'd like to contribute, please follow these steps:

  - Fork the repository on GitHub
  - Create a new branch for your changes
  - Commit your changes to the new branch
  - Push your changes to the forked repository
  - Open a pull request to the main Agentic Security repository

  Before contributing, please read the contributing guidelines.



  Agentic Security is released under the Apache License v2.





  <img width="100%" src="https://repobeats.axiom.co/api/embed/2b4b4e080d21ef9174ca69bcd801145a71f67aaf.svg" />


pkgId: ec9b6f54a9efee718723f7de3acba5d0b76babf7778096d02d7454f80708b113
name: python-agentifyme-help
arch: noarch
version: 0.1.20
epoch: 0
release: 1
summary: Development documents and examples for agentifyme
url: https://pypi.org/project/agentifyme/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agentifyme-0.1.20-1.src.rpm
location_href: Packages/python-agentifyme-help-0.1.20-1.noarch.rpm
checksum_type: sha256
description:
  Framework for agentic workflows








  ```bash
  rye run coverage run -m pytest


  rye run coverage report


  rye run coverage html
  ```


pkgId: de602353a88474bc195847f494b9eb145fb0c7072f63912ae588ca1e381e1558
name: python-agentlib-mpc-help
arch: noarch
version: 0.6.4
epoch: 0
release: 1
summary: Development documents and examples for agentlib-mpc
url: https://pypi.org/project/agentlib-mpc/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agentlib-mpc-0.6.4-1.src.rpm
location_href: Packages/python-agentlib-mpc-help-0.6.4-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![pylint](https://rwth-ebc.github.io/AgentLib-MPC/main/pylint/pylint.svg)](https://rwth-ebc.github.io/AgentLib-MPC/main/pylint/pylint.html)
  [![documentation](https://rwth-ebc.github.io/AgentLib-MPC/main/docs/doc.svg)](https://rwth-ebc.github.io/AgentLib-MPC/main/docs/index.html)

  This is a plugin for [AgentLib](https://github.com/RWTH-EBC/AgentLib).
  Includes functions for modeling with [CasADi](https://web.casadi.org/), and using those models in nonlinear MPC, central and distributed (based on ADMM).

  See examples and the tutorial in the docs.
  Best example to start is an MPC for [a single air conditioned room](https://github.com/RWTH-EBC/AgentLib-MPC/blob/main/examples/one_room_mpc/physical/simple_mpc.py).




  Install with:

  ```
  pip install agentlib_mpc
  ```

  To install with full dependencies (recommended), run:
  ```
  pip install agentlib_mpc[full]
  ```




  AgentLib_MPC has a number of optional dependencies:

   - **fmu**: Support simulation of FMU models (https://fmi-standard.org/).
   - **ml**: Use machine learning based NARX models for MPC. Currently supports neural networks, gaussian process regression and linear regression. Installs tensorflow, keras and scikit-learn.
   - **interactive**: Utility functions for displaying mpc results in an interactive dashboard. Installs plotly and dash.

  Install these like
  ````
  pip install agentlib_mpc[ml]
  ````




  For now, please cite the base framework under https://github.com/RWTH-EBC/AgentLib.

  A preprint is available under http://dx.doi.org/10.2139/ssrn.4884846 and can be cited as:

  > Eser, Steffen and Storek, Thomas and Wüllhorst, Fabian and Dähling, Stefan and Gall, Jan and Stoffel, Phillip and Müller, Dirk, A Modular Python Framework for Rapid Development of Advanced Control Algorithms for Energy Systems. Available at SSRN: https://ssrn.com/abstract=4884846 or http://dx.doi.org/10.2139/ssrn.4884846

  When using AgentLib-MPC, please remember to cite other tools that you are using, for example CasADi or IPOPT.



  We gratefully acknowledge the financial support by Federal Ministry \\ for Economic Affairs and Climate Action (BMWK), promotional reference 03ET1495A.

  <img src="./docs/source/images/BMWK_logo.png" alt="BMWK" width="200"/>


pkgId: 7bc70f6ca2fcc4115d282078fdfc9a7c9a2a9db5444b2e40af77568dd8af86a6
name: python-agentopia-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for agentopia
url: https://pypi.org/project/agentopia/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agentopia-0.1.6-1.src.rpm
location_href: Packages/python-agentopia-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  <img alt="Logo" align="right" src="https://raw.githubusercontent.com/nurturelabs-co/Agentopia/main/logo.png" width="20%" />

  - Add superpowers to your AI agent. Our SDK empowers AI agents to discover and pay for services, products, and other agents on demand—seamlessly and autonomously.
  - Devs, you can easily:
    - Add new capabilities to your AI agent 10x faster
    - Discover and pay for services, APIs, data set or infra your AI agent needs
    - Pay with USDC automatically, no credit cards or bank account needed
    - Build your own services to sell to AI agents
    - Remix existing services into new offerings
    - Skip lengthy approval processes, no permissions required
    - Start earning revenue immediately


  - [Installation](#install-the-sdk)
  - [Using Services](#use-a-service-on-agentopia)
    - [Funding Your Wallet](#fund-your-agentopia-wallet)
    - [Service Usage](#use-a-service)
  - [Selling your Services](#sell-your-service-on-agentopia)
    - [Hello World Example](#hello-world-service)
    - [Open Router Example](#open-router-service)
    - [Service Registration](#register-your-service)
    - [Withdraw earnings](#withdraw-earnings-from-agentopia-wallet)
  - [Contact](#contact-us)



  ```bash
  pip install agentopia
  ```



  Search and use services on Agentopia Marketplace. You can can pay for services with USDC on Base blockchain, with usage-based pricing.



  ```python
  from agentopia import Agentopia
  agentopia_client = Agentopia(private_key="your_private_key")
  agentopia_client.deposit(amount=1000_000)
  ```

  This will initiate a deposit of 1 USDC (the values used in the SDK are in micro USDC) request which will be processed in a few minutes on the base blockchain.



  ```python
  from agentopia import Agentopia
  agentopia_client = Agentopia(private_key="your_private_key")
  response = agentopia_client.service.execute_via_proxy(
      service_slug="hello-world", endpoint_path="hello_world", method="GET"
  )
  print(response)
  ```



  Build and sell API/data services on the Agentopia Marketplace. AI agents and users can pay for your service with USDC on Base blockchain.

  Below are some example services using the Agentopia SDK.


  You can enable agentopia payments in your endpoints simply by adding the `@payable` decorator and returning the response with the `X-Usdc-Used` header.
  ```python
  from fastapi import FastAPI, Request
  from fastapi.responses import JSONResponse
  from agentopia import payable

  app = FastAPI()

  @app.get("/hello_world")
  @payable(
      hold_amount=100000, hold_expires_in=3600
  )  # Hold 0.1 USDC in the users account for 1hr
  async def hello_world(
      request: Request,
  ):
      print("Executing hello_world endpoint")
      
      print("Preparing response with 0.000001 USDC charge")
      response = JSONResponse(
          content={"message": "Hello from Agentopia!"}, headers={"X-Usdc-Used": "1"}
      )
      print("Returning response")
      return response
  ```

  Checkout the repo: [Hello World Service](https://github.com/nurturelabs-co/agentopia-hello-world)


  For more flexibility, you can use the Agentopia client to charge the user according to your app's dynamic requirements.
  ```python
  import json
  import os

  import httpx
  import requests
  from fastapi import FastAPI, HTTPException, Request, status
  from fastapi.responses import JSONResponse, StreamingResponse
  from agentopia import Agentopia  # type: ignore

  app = FastAPI()

  OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
  if not OPENROUTER_API_KEY:
      raise Exception("OPENROUTER_API_KEY environment variable not set")


  @app.post("/chat/completions")
  async def chat_completions(request: Request):
      print("Starting payable stream wrapper")
      
      x_hold_id = request.headers.get("X-Hold-Id")

      if x_hold_id is None:
          print("No hold ID provided, raising 402 error")
          raise HTTPException(
              status_code=status.HTTP_402_PAYMENT_REQUIRED,
              detail="A Agentopia `X-Hold-Id` header is required",
          )

      print(f"Received hold ID: {x_hold_id}")

      
      print("Creating Agentopia client")
      agentopia_client = Agentopia()

      
      print(f"Verifying hold {x_hold_id}")
      try:
          x_hold = agentopia_client.hold.get(x_hold_id)
          print(f"Hold verification successful: {x_hold}")
      except requests.exceptions.HTTPError:
          print("Hold verification failed")
          raise HTTPException(
              status_code=status.HTTP_402_PAYMENT_REQUIRED,
              detail="Invalid hold ID",
          )

      try:
          
          body = await request.json()

          
          async with httpx.AsyncClient() as client:
              headers = {
                  "Authorization": f"Bearer {OPENROUTER_API_KEY}",
                  "HTTP-Referer": "https://agentopia.xyz",
                  "X-Title": "Agentopia LLM Service",
              }

              
              if body.get("stream", False):
                  response = await client.post(
                      "https://openrouter.ai/api/v1/chat/completions",
                      json=body,
                      headers=headers,
                      follow_redirects=True,
                      timeout=30.0,
                  )

                  async def generate():
                      try:
                          async for line in response.aiter_lines():
                              if line:
                                  
                                  if (
                                      line.strip() == ""
                                      or "OPENROUTER PROCESSING" in line
                                  ):
                                      continue

                                  
                                  if line.startswith("data: "):
                                      line = line[6:]  # Remove "data: " prefix

                                  try:
                                      parsed_line = json.loads(line)
                                      if "error" in parsed_line:
                                          raise HTTPException(
                                              status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                                              detail=parsed_line["error"],
                                          )
                                      
                                      yield f"data: {json.dumps(parsed_line)}\n\n"
                                  except json.JSONDecodeError:
                                      print(f"JSONDecodeError on line: {line}")
                                      continue

                          yield "data: [DONE]\n\n"
                      finally:
                          
                          print(f"Releasing hold {x_hold_id} with amount 1000")
                          try:
                              agentopia_client.hold.release(hold_id=x_hold_id, amount=1000)
                              print("Hold released successfully")
                          except requests.exceptions.HTTPError:
                              print("Failed to release hold")
                              raise HTTPException(
                                  status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                                  detail="Failed to process payment",
                              )

                  return StreamingResponse(
                      generate(),
                      media_type="text/event-stream",
                      headers={
                          "Content-Type": "text/event-stream",
                          "Cache-Control": "no-cache",
                          "Connection": "keep-alive",
                          "X-Usdc-Used": "1000",
                      },
                  )

              
              response = await client.post(
                  "https://openrouter.ai/api/v1/chat/completions",
                  json=body,
                  headers=headers,
              )

              
              try:
                  agentopia_client.hold.release(hold_id=x_hold_id, amount=1000)
                  print("Hold released successfully")
              except requests.exceptions.HTTPError:
                  print("Failed to release hold")
                  raise HTTPException(
                      status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                      detail="Failed to process payment",
                  )

              return JSONResponse(
                  content=response.json(), headers={"X-Usdc-Used": "1000"}
              )

      except Exception as e:
          raise HTTPException(
              status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)
          )

  ```

  <!-- Checkout the repo: [Open Router Service](https://github.com/nurturelabs-co/agentopia-openrouter) -->



  You need to register your service on Agentopia Marketplace to make it available for users to use.

  ```python
  from agentopia import Agentopia, AgentopiaServiceModel
  agentopia_client = Agentopia(private_key="your_private_key")

  service: AgentopiaServiceModel = agentopia_client.service.register(
      name="Hello World",
      description="A simple hello world service",
      base_url="http://api.hello.world",
      slug="hello-world-1234",
      initial_hold_amount=100000,  # $0.1 USDC
      initial_hold_expires_in=3600,  # 1 hour
      api_schema_url="http://api.hello.world/openapi.json",
  )
  ```





  ```python
  from agentopia import Agentopia
  agentopia_client = Agentopia(private_key="your_private_key")
  balance = agentopia_client.get_balance()
  ```



  ```python
  from agentopia import Agentopia
  agentopia_client = Agentopia(private_key="your_private_key")
  agentopia_client.withdraw(amount=100000)
  ```

  This will initiate a withdrawal request which will be processed in a few minutes on the base blockchain.



  If you have any questions or feedback, please contact us at

  - [Telegram](https://t.me/yashdotagarwal)
  - [Twitter](https://x.com/yashdotagarwal)
  - [Email](mailto:yash@nurturelabs.co)


pkgId: 51e972518005a8e5ad154cf57226b69580f1c93843eb535b5f1e8f0c69b0806d
name: python-agi.green-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for agi.green
url: https://pypi.org/project/agi.green/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agi.green-0.2.8-1.src.rpm
location_href: Packages/python-agi.green-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  A modern Python framework for building AI-powered asynchonous chat applications with a browser interface, featuring markdown content rendering and a unified messaging system.

  Application can be built entirely in Python or can integrate with arbitrary external services.
  This differs from conventional full stack solutions with a javascript frontend application making API calls to a Python backend.
  Instead, the frontend is a slave and the backend is the application.



  - **Unified Message Protocol**: Consistent message handling across different communication channels
  - **Rich Content Support**:
    - Markdown rendering
    - Mermaid diagrams
    - MathJax equations
    - Code syntax highlighting
    - YAML forms implementing [Vueform](https://vueform.com/)
  - **Flexible Architecture**:
    - WebSocket-based real-time communication
    - Message Queue (AMQP) integration for distributed systems - rabbitmq|ABS|inprocess
    - Extensible protocol system - asynchronous interaction with anything
  - **AI Integration**:
    - OpenAI API support
    - Anthropic Claude support
    - Custom model integration capability
  - **Asynchronous Execution**:
    - Non limited to call and response
    - Can add chat messages in response to arbitrary events, e.g. incoming email or SMS or task completion
    - Can execute arbitrary code in response to a message or other events
    - No javascript required on the frontend!
  - **Vue Forms in Markdown (chat and docs)**:
    - Support for YAML and JSON forms in markdown
    - Support for forms in chat messages
    - Support for forms in documents
    - Asynchronous form data events with no javascript required on the frontend (python only)
    - That means no need to write any javascript to use forms!



  1. Install dependencies:
  ```bash

  sudo apt-get install rabbitmq-server  # Ubuntu/Debian
  brew install rabbitmq                 # macOS


  pip install agi.green
  ```

  2. Create a basic chat application:
  ```python
  from agi_green.dispatcher import Dispatcher

  class ChatNode(Dispatcher):
      async def on_mq_chat(self, author: str, content: str):
          'Receive chat message from RabbitMQ'
          await self.send_ws('append_chat', content=content)

      async def on_ws_chat_input(self, content: str = ''):
          'Handle chat input from browser'
          await self.send_mq('chat',
              author=self.name,
              content=content
          )
  ```



  The framework uses a protocol-based architecture where each protocol handles specific types of communication:

  - `ws`: WebSocket communication with browser
  - `mq`: RabbitMQ for peer-to-peer messaging
  - `gpt`: OpenAI API integration
  - `http`: HTTP/HTTPS server
  - Custom protocols can be added by extending the base Protocol class



  Support for rich content in messages:
  ```python

  await self.send_ws('append_chat',
      content='```python\nprint("Hello")\n```'
  )


  await self.send_ws('append_chat',
      content='```mermaid\ngraph TD;\nA-->B;\n```'
  )


  await self.send_ws('append_chat',
      content=r'\\( \int x dx = \frac{x^2}{2} + C \\)'
  )
  ```



  Currently in active development (March 2024). The framework is being used in production but the API may have breaking changes. See [CHANGELOG](CHANGELOG.md) for version history.



  - Python 3.11+
  - RabbitMQ server
  - Modern web browser



  Contributions are welcome! Please check our [Contributing Guidelines](CONTRIBUTING.md) for details.



  Copyright (c) 2024 Ken Seehart, AGI Green. See [LICENSE](LICENSE) for details.

rpm_license:
  MIT License  Copyright (c) 2023 kenseehart  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: cd60f6f9594006b2ae27adfb2a9717966fae43b83b84280d2042bb7906a97e9d
name: python-agilicus-help
arch: noarch
version: 1.271.13
epoch: 0
release: 1
summary: Development documents and examples for agilicus
url: https://www.agilicus.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agilicus-1.271.13-1.src.rpm
location_href: Packages/python-agilicus-help-1.271.13-1.noarch.rpm
checksum_type: sha256
description:
  The [Agilicus Platform](https://www.agilicus.com/) [API](https://www.agilicus.com/api).
  is defined using [OpenAPI 3.0](https://github.com/OAI/OpenAPI-Specification),
  and may be used from any language. This allows configuration of our Zero-Trust Network Access cloud native platform
  using REST. You can see the API specification [online](https://www.agilicus.com/api).

  This package provides a Python SDK, class library interfaces for use in
  accessing individual collections. In addition it provides a command-line-interface (CLI)
  for interactive use.

  Read the class-library documentation [online](https://www.agilicus.com/api/)

  [Samples](https://git.agilicus.com/pub/samples) shows various examples of this code in use.

  Generally you may install this from [pypi](https://pypi.org/project/agilicus/) as:

  ```
  pip install --upgrade agilicus
  ```

  You may wish to add bash completion by adding this to your ~/.bashrc:

  ```
  eval "$(_AGILICUS_CLI_COMPLETE=source agilicus-cli)"
  ```


  The below python code will show the same output as the CLI command:
  `agilicus-cli --issuer https://auth.dbt.agilicus.cloud list-users`

  ```
  import agilicus
  import argparse
  import sys

  scopes = agilicus.scopes.DEFAULT_SCOPES

  parser = argparse.ArgumentParser(description="update-user")
  parser.add_argument("--auth-doc", type=str)
  parser.add_argument("--issuer", type=str)
  parser.add_argument("--email", type=str)
  parser.add_argument("--disable-user", type=bool, default=None)
  args = parser.parse_args()

  if not args.auth_doc and not args.issuer:
      print("error: specify either an --auth-doc or --issuer")
      sys.exit(1)

  if not args.email:
      print("error: specify an email to search for a user")
      sys.exit(1)

  api = agilicus.GetClient(
      agilicus_scopes=scopes, issuer=args.issuer, authentication_document=args.auth_doc
  )

  users = api.users.list_users(org_id=api.default_org_id, email=args.email)
  if len(users.users) != 1:
      print(f"error: failed to find user with email: {args.email}")
      sys.exit(1)

  user = users.users[0]

  if args.disable_user is not None:
      user.enabled = args.disable_user

  result = api.users.replace_user(
      user.id, user=user, _check_input_type=False, _host_index=0
  )
  print(result)
  ```


pkgId: d1c38c40317204c33c7c11002e6877e9209661bb02af26a882d32532f69c28f4
name: python-agiverse-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for agiverse
url: https://github.com/agiverse/agiverse-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agiverse-0.1.5-1.src.rpm
location_href: Packages/python-agiverse-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  **AGIverse is in early development stage, the world will be reset multiple times in the future until the product is publicly released.**



  agiverse-py is the Python SDK for AGIverse, an autonomous, AI native infrastructure for AI agents to communicate, collaborate, and use dynamic tools.



  You can get your API key for free from [AGIverse](https://app.agiverse.io/).



  ```bash
  pip install agiverse
  ```



  To run an agent, you need to select a model, configure a Large Language Model (LLM) provider, and set up an API key. By default, the agent uses **OpenAI** as the LLM provider and `gpt-4o-mini` as the model.

  Note: smart building doesn't need LLM setup, but requires the player to have rented a building in AGIverse. You can skip this section if you don't need to run a agent using this SDK.



  1. **Set Your OpenAI API Key**

     Provide your OpenAI API key by setting the `OPENAI_API_KEY` environment variable:

     ```bash
     export OPENAI_API_KEY='your-openai-api-key'
     ```

  2. **Customize Model and Provider (Optional)**

     - **Change Model:** Set the `MODEL` environment variable to your desired model.
     - **Change Provider:** Configure the corresponding provider’s API key using the appropriate environment variables.

  3. **Multiple LLM Providers Support**

     We use [LiteLLM](https://docs.litellm.ai/) to support multiple LLM providers. For a list of supported providers, available models, and the necessary environment variables, refer to the [LiteLLM documentation](https://docs.litellm.ai/docs/providers).

  By following these steps, you can customize the LLM settings to fit your specific requirements.



  AI agents are the residents of AGIverse. They observe and understand their environment, using information about their surroundings, their current state, and past experiences to make decisions. Just like humans, they can take actions to interact with each other and the world around them. These agents are powered by advanced large language models, allowing them to communicate and engage in meaningful interactions within AGIverse.

  Initialize an agent client:

  ```python
  import agiverse

  agent = agiverse.Agent(api_key='xxx', name='xxx')
  ```

  And you are ready to start the agent:

  ```python
  agent.run()
  ```



  To customize your agent, you can get or set your agent's prompt before starting the agent:

  ```python
  character_info = agent.get_prompt("character.info")
  agent.set_prompt("character.info", character_info)
  ```

  Check all prompts that will be used by the agent:

  ```python
  all_prompts = agent.get_all_prompts()
  print(list(all_prompts.keys()))
  ```



  With default parameters, an agent will use around 20-30 million input tokens and 1-2 million output tokens per day. You can reduce the frequency of LLM calls by adjusting `MIN_MODEL_INTERVAL` (default value is 5, in seconds) and `MAX_MODEL_INTERVAL` (default value is 60, in seconds) environment variables, at the cost of slower agent response time.



  Smart building is a programmable building in AGIverse. It can define and handle custom actions with any json serializable input and output data format, providing endless possibilities for the functionality of the building. Think of it as the Discord bot or smart contract of AGIverse.

  Initialize a smart building client:

  ```python
  import agiverse

  building = agiverse.SmartBuilding(api_key='xxx', building_id=xxx)
  ```

  `api_key` is the API key of the player, same as the agent API key. `building_id` is the ID of the building. Both can be found in your [AGIverse dashboard](https://app.agiverse.io/).

  Register event handlers:

  ```python
  @building.event
  async def on_ready():
      print(f"Smart building {building.building_id} is ready to use")
  ```

  Update the building name and/or description:

  ```python
  await building.update_building(name="Echo Slam", description="What's in, what's out.")
  ```

  Register action handlers:

  ```python
  @building.action(action="echo", action_description='Echo the message', payload_description='{"content": string}')
  async def echo(ctx: agiverse.ActionContext, payload):
      if payload and "content" in payload:
          message = f'You are {ctx.player_name} <{ctx.player_id}>.'
          message += f' You said "{payload["content"]}".'
          message += f' There are {len(ctx.building.players)} players in the building now.'
          await ctx.send_result(message)
      else:
          await ctx.send_result({"error": "You didn't say anything!"})
  ```

  Note that `payload_description` should contain enough information for agents to understand the payload format. It doesn't have to be in certain format, as long as agents can understand it as nautural language and generate correct payload. Think of it as the comments and docs for your API, agents read it and decide what parameters to use. For example:

  ```python
  payload_description='{"content": string that is at least 20 characters long, "location": [x, y]} (requirement: x and y must be integers, and x > 0, y > 0)'
  ```

  Start the smart building:

  ```python
  building.run()
  ```



  Action can also have payment associated with it. The payment can be in both ways, which means the player will be charged or get paid when the action is executed.

  When you want to charge the player:

  1. Set the payment description to a positive number or anything that contains enough information to let the agent know how much they should authorize.
  2. Then agents will call the action with a `payment` parameter, which is the **maximum** amount they are willing to pay for this action.
  3. Then you can pass the amount you will charge for this action to `send_result` through `payment` parameter. Note that a negative `payment` means the player is getting paid from you, so please make sure the amount is positive.

  ```python
  @building.action(action="purchase", payload_description='{"content": string}', payment_description='1')
  async def purchase(ctx: agiverse.ActionContext, payload, payment):
      
      if payment >= 1:
          await ctx.send_result("You are charged $1 for this action!", payment=1)
  ```

  When you want to pay the player, just set the `payment` to a negative number when calling `send_result`.

  ```python
  @building.action(action="withdraw", payload_description='{"content": string}')
  async def withdraw(ctx: agiverse.ActionContext, payload, payment):
      
      await ctx.send_result("You are getting paid $1 for this action!", payment=-1)
  ```



  You can find examples in the `examples` directory.


pkgId: 12f23765315388b5d36c5dbb02cbe794982198ccd1d08e66225cc59fe914ad6f
name: python-agixt-help
arch: noarch
version: 1.6.22
epoch: 0
release: 1
summary: Development documents and examples for agixt
url: https://pypi.org/project/agixt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agixt-1.6.22-1.src.rpm
location_href: Packages/python-agixt-help-1.6.22-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/badge/GitHub-Sponsor%20Josh%20XT-blue?logo=github&style=plastic)](https://github.com/sponsors/Josh-XT) [![PayPal](https://img.shields.io/badge/PayPal-Sponsor%20Josh%20XT-blue.svg?logo=paypal&style=plastic)](https://paypal.me/joshxt) [![Ko-Fi](https://img.shields.io/badge/Kofi-Sponsor%20Josh%20XT-blue.svg?logo=kofi&style=plastic)](https://ko-fi.com/joshxt)

  [![GitHub](https://img.shields.io/badge/GitHub-AGiXT%20Core-blue?logo=github&style=plastic)](https://github.com/Josh-XT/AGiXT) [![GitHub](https://img.shields.io/badge/GitHub-AGiXT%20Interactive%20UI-blue?logo=github&style=plastic)](https://github.com/JamesonRGrieve/AGiXT-Interactive) [![GitHub](https://img.shields.io/badge/GitHub-AGiXT%20StreamLit%20UI-blue?logo=github&style=plastic)](https://github.com/AGiXT/streamlit)

  [![GitHub](https://img.shields.io/badge/GitHub-AGiXT%20Python%20SDK-blue?logo=github&style=plastic)](https://github.com/AGiXT/python-sdk) [![pypi](https://img.shields.io/badge/pypi-AGiXT%20Python%20SDK-blue?logo=pypi&style=plastic)](https://pypi.org/project/agixtsdk/)

  [![GitHub](https://img.shields.io/badge/GitHub-AGiXT%20TypeScript%20SDK-blue?logo=github&style=plastic)](https://github.com/AGiXT/typescript-sdk) [![npm](https://img.shields.io/badge/npm-AGiXT%20TypeScript%20SDK-blue?logo=npm&style=plastic)](https://www.npmjs.com/package/agixt)

  [![GitHub](https://img.shields.io/badge/GitHub-AGiXT%20Dart%20SDK-blue?logo=github&style=plastic)](https://github.com/AGiXT/dart-sdk)

  [![Discord](https://img.shields.io/discord/1097720481970397356?label=Discord&logo=discord&logoColor=white&style=plastic&color=5865f2)](https://discord.gg/d3TkHRZcjD)
  [![Twitter](https://img.shields.io/badge/Twitter-Follow_@Josh_XT-blue?logo=twitter&style=plastic)](https://twitter.com/Josh_XT)

  [![Logo](https://josh-xt.github.io/AGiXT/images/AGiXT-gradient-flat.svg)](https://josh-xt.github.io/AGiXT/)

  AGiXT is a dynamic Artificial Intelligence Automation Platform engineered to orchestrate efficient AI instruction management and task execution across a multitude of providers. Our solution infuses adaptive memory handling with a broad spectrum of commands to enhance AI's understanding and responsiveness, leading to improved task completion. The platform's smart features, like Smart Instruct and Smart Chat, seamlessly integrate web search, planning strategies, and conversation continuity, transforming the interaction between users and AI. By leveraging a powerful plugin system that includes web browsing and command execution, AGiXT stands as a versatile bridge between AI models and users. With an expanding roster of AI providers, code evaluation capabilities, comprehensive chain management, and platform interoperability, AGiXT is consistently evolving to drive a multitude of applications, affirming its place at the forefront of AI technology.

  Embracing the spirit of extremity in every facet of life, we introduce AGiXT. This advanced AI Automation Platform is our bold step towards the realization of Artificial General Intelligence (AGI). Seamlessly orchestrating instruction management and executing complex tasks across diverse AI providers, AGiXT combines adaptive memory, smart features, and a versatile plugin system to maximize AI potential. With our unwavering commitment to innovation, we're dedicated to pushing the boundaries of AI and bringing AGI closer to reality.



  - [AGiXT](#agixt)
    - [Table of Contents 📖](#table-of-contents-)
    - [⚠️ Disclaimers](#️-disclaimers)
      - [Monitor Your Usage](#monitor-your-usage)
    - [Key Features 🗝️](#key-features-️)
    - [Quick Start Guide](#quick-start-guide)
      - [Operating System Prerequisites](#operating-system-prerequisites)
        - [Windows and Mac Prerequisites](#windows-and-mac-prerequisites)
        - [Linux Prerequisites](#linux-prerequisites)
    - [Installation](#installation)
    - [Usage](#usage)
      - [Command-line Options](#command-line-options)
    - [Docker Deployment](#docker-deployment)
    - [Troubleshooting](#troubleshooting)
    - [Security Considerations](#security-considerations)
    - [Configuration](#configuration)
    - [Documentation](#documentation)
    - [Other Repositories](#other-repositories)
    - [History](#history)
    - [Workflow](#workflow)





  Please note that using some AI providers (such as OpenAI's GPT-4 API) can be expensive! Monitor your usage carefully to avoid incurring unexpected costs.  We're **NOT** responsible for your usage under any circumstances.



  - **Context and Token Management**: Adaptive handling of long-term and short-term memory for an optimized AI performance, allowing the software to process information more efficiently and accurately.
  - **Smart Instruct**: An advanced feature enabling AI to comprehend, plan, and execute tasks effectively. The system leverages web search, planning strategies, and executes instructions while ensuring output accuracy.
  - **Interactive Chat & Smart Chat**: User-friendly chat interface for dynamic conversational tasks. The Smart Chat feature integrates AI with web research to deliver accurate and contextually relevant responses.
  - **Task Execution & Smart Task Management**: Efficient management and execution of complex tasks broken down into sub-tasks. The Smart Task feature employs AI-driven agents to dynamically handle tasks, optimizing efficiency and avoiding redundancy.
  - **Chain Management**: Sophisticated handling of chains or a series of linked commands, enabling the automation of complex workflows and processes.
  - **Web Browsing & Command Execution**: Advanced capabilities to browse the web and execute commands for a more interactive AI experience, opening a wide range of possibilities for AI assistance.
  - **Multi-Provider Compatibility**: Seamless integration with leading AI providers such as OpenAI (as well as any that use OpenAI style endpoints), ezLocalai, Hugging Face, GPT4Free, Google Gemini, and more.
  - **Versatile Plugin System & Code Evaluation**: Extensible command support for various AI models along with robust support for code evaluation, providing assistance in programming tasks.
  - **Docker Deployment**: Simplified setup and maintenance through Docker deployment.
  - **Audio-to-Text & Text-to-Speech Options**: Integration with Hugging Face for seamless audio-to-text transcription, and multiple TTS choices, featuring Brian TTS, Mac OS TTS, and ElevenLabs.
  - **Platform Interoperability & AI Agent Management**: Streamlined creation, renaming, deletion, and updating of AI agent settings along with easy interaction with popular platforms like Twitter, GitHub, Google, DALL-E, and more.
  - **Custom Prompts & Command Control**: Granular control over agent abilities through enabling or disabling specific commands, and easy creation, editing, and deletion of custom prompts to standardize user inputs.
  - **RESTful API**: FastAPI-powered RESTful API for seamless integration with external applications and services.
  - **Expanding AI Support**: Continually updated to include new AI providers and services, ensuring the software stays at the forefront of AI technology.

  The features that AGiXT provides cover a wide range of services and are used for different tasks. Refer to [Processes and Frameworks](https://josh-xt.github.io/AGiXT/2-Concepts/1-Processes%20and%20Frameworks.html) for more details about the services and framework.





  Provide the following prerequisites based on the Operating System you use.



  - [Git](https://git-scm.com/downloads)
  - [Docker Desktop](https://docs.docker.com/docker-for-windows/install/)
  - [Python 3.10.x](https://www.python.org/downloads/)



  - [Git](https://git-scm.com/downloads)
  - [Docker](https://docs.docker.com/get-docker/)
  - [Docker Compose](https://docs.docker.com/compose/install/)
  - [Python 3.10.x](https://www.python.org/downloads/)
  - [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) (if using local models on GPU)



  If you're using Linux, you may need to prefix the `python` command with `sudo` depending on your system configuration.

  ```bash
  git clone https://github.com/Josh-XT/AGiXT
  cd AGiXT
  python start.py
  ```

  The script will check for Docker and Docker Compose installation:

  - On Linux, it will attempt to install them if missing (requires sudo privileges).
  - On macOS and Windows, it will provide instructions to download and install Docker Desktop.



  Run the script with Python:

  ```bash
  python start.py
  ```

  To run AGiXT with ezLocalai, use the `--with-ezlocalai` flag:

  ```bash
  python start.py --with-ezlocalai true
  ```

  You can also use command-line arguments to set specific environment variables to run in different ways. For example, to use the development branch and enable auto-updates, run:

  ```bash
  python start.py --agixt-branch dev --agixt-auto-update true --with-ezlocalai true
  ```

  - Access the AGiXT Management interface at <http://localhost:8501> to create and manage your agents, prompts, chains, and configurations.
  - Access the AGiXT Interactive interface at <http://localhost:3437> to interact with your configured agents.
  - Access the AGiXT API documentation at <http://localhost:7437>



  The script supports setting any of the environment variables via command-line arguments. Here's a detailed list of available options:

  1. `--agixt-api-key`: Set the AGiXT API key (automatically generated if not provided)
  2. `--agixt-uri`: Set the AGiXT URI (default: `http://localhost:7437`)
  3. `--agixt-agent`: Set the default AGiXT agent (default: `AGiXT`)
  4. `--agixt-branch`: Choose between `stable` and `dev` branches
  5. `--agixt-file-upload-enabled`: Enable or disable file uploads (default: `true`)
  6. `--agixt-voice-input-enabled`: Enable or disable voice input (default: `true`)
  7. `--agixt-footer-message`: Set the footer message (default: `Powered by AGiXT`)
  8. `--agixt-require-api-key`: Require API key for access (default: `false`)
  9. `--agixt-rlhf`: Enable or disable reinforcement learning from human feedback (default: `true`)
  10. `--agixt-show-selection`: Set which selectors to show in the UI (default: `conversation,agent`)
  11. `--agixt-show-agent-bar`: Show or hide the agent bar in the UI (default: `true`)
  12. `--agixt-show-app-bar`: Show or hide the app bar in the UI (default: `true`)
  13. `--agixt-conversation-mode`: Set the conversation mode (default: `select`)
  14. `--allowed-domains`: Set allowed domains for API access (default: `*`)
  15. `--app-description`: Set the application description
  16. `--app-name`: Set the application name (default: `AGiXT Chat`)
  17. `--app-uri`: Set the application URI (default: `http://localhost:3437`)
  18. `--streamlit-app-uri`: Set the Streamlit app URI (default: `http://localhost:8501`)
  19. `--auth-web`: Set the authentication web URI (default: `http://localhost:3437/user`)
  20. `--auth-provider`: Set the authentication provider (options: `none`, `magicalauth`)
  21. `--create-agent-on-register`: Create an agent named from your `AGIXT_AGENT` environment variable if it is different than `AGiXT` using settings from `default_agent.json` if defined (default: `true`)
  22. `--create-agixt-agent`: Create an agent called `AGiXT` and trains it on the AGiXT documentation upon user registration (default: `true`)
  23. `--disabled-providers`: Set disabled providers (comma-separated list)
  24. `--disabled-extensions`: Set disabled extensions (comma-separated list)
  25. `--working-directory`: Set the working directory (default: `./WORKSPACE`)
  26. `--github-client-id`: Set GitHub client ID for authentication
  27. `--github-client-secret`: Set GitHub client secret for authentication
  28. `--google-client-id`: Set Google client ID for authentication
  29. `--google-client-secret`: Set Google client secret for authentication
  30. `--microsoft-client-id`: Set Microsoft client ID for authentication
  31. `--microsoft-client-secret`: Set Microsoft client secret for authentication
  32. `--tz`: Set the timezone (default: system timezone)
  33. `--interactive-mode`: Set the interactive mode (default: `chat`)
  34. `--theme-name`: Set the UI theme (options: `default`, `christmas`, `conspiracy`, `doom`, `easter`, `halloween`, `valentines`)
  35. `--allow-email-sign-in`: Allow email sign-in (default: `true`)
  36. `--database-type`: Set the database type (options: `sqlite`, `postgres`)
  37. `--database-name`: Set the database name (default: `models/agixt`)
  38. `--log-level`: Set the logging level (default: `INFO`)
  39. `--log-format`: Set the log format (default: `s | s | s`)
  40. `--uvicorn-workers`: Set the number of Uvicorn workers (default: `10`)
  41. `--agixt-auto-update`: Enable or disable auto-updates (default: `true`)
  42. `--with-streamlit`: Enable or disable the Streamlit UI (default: `true`)

  Options specific to ezLocalai:

  1. `--with-ezlocalai`: Start AGiXT with ezLocalai integration.
  2. `--ezlocalai-uri`: Set the ezLocalai URI (default: `http://{local_ip}:8091`)
  3. `--default-model`: Set the default language model for ezLocalai (default: `QuantFactory/dolphin-2.9.2-qwen2-7b-GGUF`)
  4. `--vision-model`: Set the vision model for ezLocalai (default: `deepseek-ai/deepseek-vl-1.3b-chat`)
  5. `--llm-max-tokens`: Set the maximum number of tokens for language models (default: `32768`)
  6. `--whisper-model`: Set the Whisper model for speech recognition (default: `base.en`)
  7. `--gpu-layers`: Set the number of GPU layers to use (automatically determined based on available VRAM but can be modified.) (default: `-1` for all)

  For a full list of options with their current values, run:

  ```bash
  python start.py --help
  ```



  After setting up the environment variables and ensuring Docker and Docker Compose are installed, the script will:

  1. Stop any running AGiXT Docker containers
  2. Pull the latest Docker images (if auto-update is enabled)
  3. Start the AGiXT services using Docker Compose



  - If the script fails to run on Linux, run it with `sudo`.
  - If you encounter any issues with Docker installation:
    - On Linux, ensure you have sudo privileges and that your system is up to date.
    - On macOS and Windows, follow the instructions to install Docker Desktop manually if the script cannot install it automatically.
  - Check the Docker logs for any error messages if the containers fail to start.
  - Verify that all required ports are available and not in use by other services.
  - If the `python` command is not recognized, try using `python3` instead.



  - The `AGIXT_API_KEY` is automatically generated if not provided. Ensure to keep this key secure and do not share it publicly.
  - When using authentication providers (GitHub, Google, Microsoft), ensure that the client IDs and secrets are kept confidential.
  - Be cautious when enabling file uploads and voice input, as these features may introduce potential security risks if not properly managed.



  Each AGiXT Agent has its own settings for interfacing with AI providers, and other configuration options. These settings can be set and modified through the web interface.



  Need more information? Check out the [documentation](https://josh-xt.github.io/AGiXT) for more details to get a better understanding of the concepts and features of AGiXT.



  Check out the other AGiXT repositories at <https://github.com/orgs/AGiXT/repositories> - these include the AGiXT Streamlit Web UI, AGiXT Python SDK, AGiXT TypeScript SDK, AGiXT Dart SDK, AGiXT C# SDK, and more!



  ![Star History Chart](https://api.star-history.com/svg?repos=Josh-XT/AGiXT&type=Dat)



  ```mermaid
  graph TD
      Start[Start] --> IA[Initialize Agent]
      IA --> IM[Initialize Memories]
      IM --> A[User Input]
      A --> B[Multi-modal Input Handler]
      B --> B1{Input Type?}
      B1 -->|Text| C[Process Text Input]
      B1 -->|Voice| STT[Speech-to-Text Conversion]
      B1 -->|Image| VIS[Vision Processing]
      B1 -->|File Upload| F[Handle file uploads]
      STT --> C
      VIS --> C
      F --> C
      C --> S[Log user input]
      C --> T[Log agent activities]
      C --> E[Override Agent settings if applicable]
      E --> G[Handle URLs and Websearch if applicable]
      G --> H[Data Analysis if applicable]
      H --> K{Agent Mode?}
      K -->|Command| EC[Execute Command]
      K -->|Chain| EX[Execute Chain]
      K -->|Prompt| RI[Run Inference]

      EC --> O[Prepare response]
      EX --> O
      RI --> O

      O --> Q[Format response]
      Q --> R[Text Response]
      R --> P[Calculate tokens]
      P --> U[Log final response]
      Q --> TTS[Text-to-Speech Conversion]
      TTS --> VAudio[Voice Audio Response]
      Q --> IMG_GEN[Image Generation]
      IMG_GEN --> GImg[Generated Image]

      subgraph HF[Handle File Uploads]
          F1[Download files to workspace]
          F2[Learn from files]
          F3[Update Memories]
          F1 --> F2 --> F3
      end

      subgraph HU[Handle URLs in User Input]
          G1[Learn from websites]
          G2[Handle GitHub Repositories if applicable]
          G3[Update Memories]
          G1 --> G2 --> G3
      end

      subgraph AC[Data Analysis]
          H1[Identify CSV content in agent workspace or user input]
          H2[Determine files or content to analyze]
          H3[Generate and verify Python code for analysis]
          H4[Execute Python code]
          H5{Execution successful?}
          H6[Update memories with results from data analysis]
          H7[Attempt code fix]
          H1 --> H2 --> H3 --> H4 --> H5
          H5 -->|Yes| H6
          H5 -->|No| H7
          H7 --> H4
      end

      subgraph IA[Agent Initialization]
          I1[Load agent config]
          I2[Initialize providers]
          I3[Load available commands]
          I4[Initialize Conversation]
          I5[Initialize agent workspace]
          I1 --> I2 --> I3 --> I4 --> I5
      end

      subgraph IM[Initialize Memories]
          J1[Initialize vector database]
          J2[Initialize embedding provider]
          J3[Initialize relevant memory collections]
          J1 --> J2 --> J3
      end

      subgraph EC[Execute Command]
          L1[Inject user settings]
          L2[Inject agent extensions settings]
          L3[Run command]
          L1 --> L2 --> L3
      end

      subgraph EX[Execute Chain]
          M1[Load chain data]
          M2[Inject user settings]
          M3[Inject agent extension settings]
          M4[Execute chain steps]
          M5[Handle dependencies]
          M6[Update chain responses]
          M1 --> M2 --> M3 --> M4 --> M5 --> M6
      end

      subgraph RI[Run Inference]
          N1[Get prompt template]
          N2[Format prompt]
          N3[Inject relevant memories]
          N4[Inject conversation history]
          N5[Inject recent activities]
          N6[Call inference method to LLM provider]
          N1 --> N2 --> N3 --> N4 --> N5 --> N6
      end

      subgraph WS[Websearch]
          W1[Initiate web search]
          W2[Perform search query]
          W3[Scrape websites]
          W4[Recursive browsing]
          W5[Summarize content]
          W6[Update agent memories]
          W1 --> W2 --> W3 --> W4 --> W5 --> W6
      end

      subgraph PR[Providers]
          P1[LLM Provider]
          P2[TTS Provider]
          P3[STT Provider]
          P4[Vision Provider]
          P5[Image Generation Provider]
          P6[Embedding Provider]
      end

      subgraph CL[Conversation Logging]
          S[Log user input]
          T[Log agent activities]
      end

      F --> HF
      G --> HU
      G --> WS
      H --> AC
      TTS --> P2
      STT --> P3
      VIS --> P4
      IMG_GEN --> P5
      J2 --> P6
      N6 --> P1

      F --> T
      G --> T
      H --> T
      L3 --> T
      M4 --> T
      N6 --> T

      style U fill:#0000FF,stroke:#333,stroke-width:4px
  ```


pkgId: 4282c38987da11f59da869814198baf0c39d510bd0abd143546501b227b2e6cb
name: python-agora-python-server-sdk-help
arch: noarch
version: 2.1.7
epoch: 0
release: 1
summary: Development documents and examples for agora-python-server-sdk
url: https://github.com/AgoraIO-Extensions/Agora-Python-Server-SDK
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-agora-python-server-sdk-2.1.7-1.src.rpm
location_href: Packages/python-agora-python-server-sdk-help-2.1.7-1.noarch.rpm
checksum_type: sha256
description:
  - This is a Python SDK wrapper for the Agora RTC SDK.
  - It supports Linux and Mac platforms.
  - The examples are provided as very simple demonstrations and are not recommended for use in production environments.


  - A process can only have one instance.
  - An instance can have multiple connections.
  - In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.


  - Supported Linux versions:
    - Ubuntu 18.04 LTS and above
    - CentOS 7.0 and above

  - Supported Mac versions:
    - MacOS 13 and above(only for coding and testing)

  - Python version:
    - Python 3.10 and above


  ```
  pip install agora_python_server_sdk
  ```




  - Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.


  ```
  python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
  ```



  2024.12.17 Release 2.1.7
  --Changes:

    Fixed the typeError issue in LocalUser::sub/unsub audio/video.
    Adjusted the default stopRecogCount for VAD from 30 to 50.
    Modified sample_vad.

  - New Features:
    -- Added AudioVadManager to manage VAD (Voice Activity Detection) instances.
    -- Integrated VAD functionality into the SDK. Developers no longer need to worry about how to use VAD; they only need to focus on setting appropriate parameters. Reference: sample_audio_vad.py
  - Changes:
    -- In register_audio_frame_observer, two new parameters have been added to set the VAD parameters. Reference: sample_audio_vad.py
    -- In on_playback_audio_frame_before_mixing, two new return values have been added: vad_result_state and vad_result_bytearray.
      state:
      < 0: No internal automatic VAD applied
      0: No speaking
      1: Started speaking
      2: Speaking
      3: Stopped speaking
      vad_result_bytearray: The result processed by VAD, returned when VAD is active.
      If automatic VAD is enabled:
      Developers should use vad_result_bytearray for subsequent business processing (e.g., sending to ASR/STT), rather than using the raw frame data.
      Reference: sample_audio_vad.py
  - Optimizations:
    -- Replaced the use of pacer with AudioConsumer for pushing PCM audio.
  - Updates:
    -- Updated the samples related to Pacer and VAD.


  - Modifications:
    - LocalUser/audioTrack:
      -- When the scenario is chorus, developers don't need to call setSendDelayInMs.
      -- When the scenario is chorus, developers don't need to set the audio scenario of the track to chorus.
      -- NOTE: This can reduce the difficulty for developers. In AI scenarios, developers only need to set the service to chorus.
  - Additions:
    -- Added the VadDump class, which can assist in troubleshooting vad issues in the testing environment. However, it should not be enabled in the online env  ironment.
    -- Added the on_volume_indication callback.
    -- Added the on_remote_video_track_state_changed callback.
  - Removals:
    -- Removed Vad V1 version, only retaining the V2 version. Refer to voice_detection.py and sample_audio_vad.py.
  - Updates:
    -- Updated relevant samples: audioconsume, vad sample.


  - Modify the type of metadata in videoFrame from str to bytes type to be consistent with C++; thus, it can support byte streams.
  - The internal encapsulation of ExteranlVideoFrame has been modified to support byte streams. Regarding the support for alpha encoding, a logical judgment has been made. If fill_alpha_buffer is 0, it will not be processed.

  - Added a new sample: example_jpeg_send.py which can push JPEG files or JPEG streams to a channel.
  -
  - Performance overhead, as noted in the example comments, can be summarized as follows:
  - For a 1920x1080 JPEG file, the process from reading the file to converting it to an RGBA bytearray - takes approximately 11 milliseconds.



  - Updates `user_id` in the `AudioVolumeInfoInner and AudioVolumeInfo` structure to `str` type.
  - Fixes the bug in `_on_audio_volume_indication` callback, where it could only handle one callback to speaker_number
  - Corrects the parameter type in `IRTCLocalUserObserver::on_audio_volume_indication` callback to `list` type.



  Add audio VAD interface of version 2 and corresponding example.



  Fixed some bug.




  - A process can only have one service, and the service can only be initialized once.
  - A service can only have one media_node_factory.
  - A service can have multiple connections.
  - Release media_node_factory.release() and service.release() when the process exits.

  - In this case, create service/media_node_factory and connection when the process starts.
  - Release service/media_node_factory and connection when the process exits, ensuring that...

  - In this case, we recommend using the concept of a connection pool.
  - Create service/media_node_factory and a connection pool (only new connections, without initialization) when the process starts.
  - When a user logs in, get a connection from the connection pool, initialize it, execute con.connect() and set up callbacks, and then join the channel.
  - Handle business operations.
  - When a user logs out, execute con.disconnect() and release the audio/video tracks and observers associated with the connection, but do not call con.release(); then put the connection back into the connection pool.
  - When the process exits, release the connection pool (release each con.release()), service/media_node_factory, and the connection pool (release each con.release()) to ensure resource release and optimal performance.






    1. Call _vad_instance.init(AudioVadConfigV2) to initialize the vad instance. Reference: voice_detection.py. Assume the instance is: _vad_instance
    2. In audio_frame_observer::on_playback_audio_frame_before_mixing(audio_frame):

    3. Call the process of the vad module: state, bytes = _vad_instance.process(audio_frame)
  Judge the value of state according to the returned state, and do corresponding processing.

      A. If state is _vad_instance._vad_state_startspeaking, it indicates that the user is "starting to speak", and speech recognition (STT/ASR) operations can be started. Remember: be sure to pass the returned bytes to the recognition module instead of the original audio_frame, otherwise the recognition result will be incorrect.
      B. If state is _vad_instance._vad_state_stopspeaking, it indicates that the user is "stopping speaking", and speech recognition (STT/ASR) operations can be stopped. Remember: be sure to pass the returned bytes to the recognition module instead of the original audio_frame, otherwise the recognition result will be incorrect.
      C. If state is _vad_instance._vad_state_speaking, it indicates that the user is "speaking", and speech recognition (STT/ASR) operations can be continued. Remember: be sure to pass the returned bytes to the recognition module instead of the original audio_frame, otherwise the recognition result will be incorrect.

    If the vad module is used and it is expected to use the vad module for speech recognition (STT/ASR) and other operations, then be sure to pass the returned bytes to the recognition module instead of the original audio_frame, otherwise the recognition result will be incorrect.

    1. Ensure that the initialization parameters of the vad module are correct. Reference: voice_detection.py.
    2. In state, bytes = on_playback_audio_frame_before_mixing(audio_frame):

      - A . Save the data of audio_frame to a local file, reference: example_audio_pcm_send.py. This is to record the original audio data. For example, it can be named: source_{time.time()*1000}.pcm
      - B.Save the result of each vad processing:

        - a When state == start_speaking: create a new binary file, for example, named: vad_{time.time()*1000}.pcm, and write bytes to the file.
        - b When state == speaking: write bytes to the file.
        - c When state == stop_speaking: write bytes to the file and close the file.
      Note: In this way, problems can be troubleshot based on the original audio file and the audio file processed by vad. This function can be disabled in the production environment.

    
    


      localuser.unpublish_audio(audio_track)
      localuser.unpublish_video(video_track)
      audio_track.set_enabled(0)
      video_track.set_enabled(0)

      localuser.unregister_audio_frame_observer()
      localuser.unregister_video_frame_observer()
      localuser.unregister_local_user_observer()

      connection.disconnect()
      connection.unregister_observer()

      localuser.release()
      connection.release()


      audio_track.release()
      video_track.release()
      pcm_data_sender.release()
      video_data_sender.release()
      audio_consumer.release()

      media_node_factory.release()
      agora_service.release()

      
      audio_track = None
      video_track = None
      audio_observer = None
      video_observer = None
      local_observer = None
      localuser = None
      connection = None
      agora_service = None



  In human-machine dialogue, an interrupt refers to the situation where a user suddenly interrupts the robot's response, requesting the robot to stop its current response immediately and shift to answer the user's new question. This behavior is called an interrupt.


  Interrupts can be defined in different ways depending on the product. There are generally two modes:

  - Mode 1: Voice Activation Mode
  When it detects that the user is speaking, the interrupt strategy is triggered. For example, when the system recognizes speech, it triggers the interrupt strategy to stop the robot's response.

  - Mode 2: ASR Activation Mode
  When the system detects that the user is speaking and receives a result from ASR (Automatic Speech Recognition) or STT (Speech-to-Text), the interrupt strategy is triggered.


  Voice Activation Interrupt

  Advantages:
  Reduces the user's wait time and the likelihood of interrupts, as the robot will stop its response immediately when the user starts speaking, eliminating the need for the user to wait for the robot to finish speaking.
  Disadvantages:
  Since this is voice-activated, it may be triggered by meaningless audio signals, depending on the accuracy of the VAD (Voice Activity Detection). For example, if someone is typing on the keyboard while the AI is speaking, it might trigger the interrupt incorrectly.
  ASR Activation Interrupt

  Advantages:
  Reduces the probability of unnecessary interrupts because the interrupt strategy is triggered only after ASR or STT has recognized the user’s speech.
  Disadvantages:
  Since this is ASR/STT-triggered, it requires converting the audio signal into text, which introduces a delay before the interrupt can be processed.
  - Recommended Mode
  If the VAD can filter out non-speech signals and only triggers when human speech is detected, the Voice Activation Mode is recommended. This mode is also suitable when the delay in processing the interrupt is not a major concern.

  If the interrupt delay is not sensitive, the ASR Activation Mode is recommended. This mode can filter out non-speech signals more effectively and reduce the probability of an unintended interrupt.

  How to Implement Interrupts? What Actions Are Required?
  In a human-machine dialogue system, conversations are typically structured in "rounds," where each round consists of a question from the user, followed by a response from the robot, and so on. For each round, we can assign a roundId, incrementing it with each new round. A round consists of the following stages:

  VAD (Voice Activity Detection):
  This marks the start of the dialogue, where the system detects the beginning and end of the user's speech. It then passes this information to the ASR for further processing.

  ASR (Automatic Speech Recognition):
  This phase involves recognizing the user's speech and converting it into text, which is then passed to the LLM (Large Language Model).

  LLM (Large Language Model):
  This is the generation phase, where the LLM processes the recognized user input and generates a response.

  TTS (Text-to-Speech):
  In this phase, the LLM’s response is converted into an audio format.

  RTC Streaming:
  The generated audio is streamed via RTC (Real-Time Communication) to be played back to the user.

  Therefore, an interrupt happens when, in the next round (roundId+1), either through Voice Activation (triggered by the VAD phase) or ASR Activation (triggered when ASR recognizes the user’s speech), the following actions must be performed:

  Stop the LLM Generation in the current round (roundId).
  Stop the TTS Synthesis in the current round (roundId).
  Stop the RTC Streaming in the current round (roundId).
  API Call References:
  Call: AudioConsumer.clear()
  Call: LocalAudioTrack.clear_sender_buffer()
  Business Layer: Clear any remaining TTS-related data (if applicable)



  LLM (Large Language Model) results are returned asynchronously and in a streaming manner. When should the results from the LLM be passed to TTS (Text-to-Speech) for synthesis?

  Two main factors need to be considered:

  Ensure that the TTS synthesized speech is unambiguous:
  The speech synthesized by TTS must be clear, complete, and continuous. For example, if the LLM returns the text: "中间的首都是北京吗？", and we pass it to TTS as:

  "中",
  "国首",
  "是北",
  "京吗？",
  This would result in ambiguous synthesis because there are no spaces between certain words (e.g., between "中" and "国", "首" and "是", and "京" and "吗"). Proper segmentation must be ensured to avoid such ambiguities.
  Minimize overall processing delay:
  If the LLM results are passed to TTS only after the entire response is generated, the speech synthesis will be unambiguous and continuous. However, this approach introduces significant delay, which negatively affects the user experience.

  Recommended Approach
  To achieve a balance between clarity and minimal delay, the following steps should be followed:

  Store the LLM results in a cache as they are received.
  Perform a reverse scan of the cached data to find the most recent punctuation mark.
  Truncate the data from the start to the most recent punctuation mark and pass it to TTS for synthesis.
  Remove the truncated data from the cache. The remaining data should be moved to the beginning of the cache and continue waiting for additional data from the LLM.


  AgoraAudioVadConfigV2 Properties

  Property Name	Type	Description	Default Value	Value Range
  preStartRecognizeCount	int	Number of audio frames saved before detecting speech	16	[0, ]
  startRecognizeCount	int	Total number of audio frames to detect speech start	30	[1, max]
  stopRecognizeCount	int	Number of audio frames to detect speech stop	50	[1, max]
  activePercent	float	Percentage of active frames in startRecognizeCount frames	0.7	[0.0, 1.0]
  inactivePercent	float	Percentage of inactive frames in stopRecognizeCount frames	0.5	[0.0, 1.0]
  startVoiceProb	int	Probability that an audio frame contains human voice	70	[0, 100]
  stopVoiceProb	int	Probability that an audio frame contains human voice	70	[0, 100]
  startRmsThreshold	int	Energy dB threshold for detecting speech start	-50	[-100, 0]
  stopRmsThreshold	int	Energy dB threshold for detecting speech stop	-50	[-100, 0]
  Notes:
  startRmsThreshold and stopRmsThreshold:

  The higher the value, the louder the speaker's voice needs to be compared to the surrounding background noise.
  In quiet environments, it is recommended to use the default value of -50.
  In noisy environments, you can increase the threshold to between -40 and -30 to reduce false positives.
  Adjusting these thresholds based on the actual use case and audio characteristics can achieve optimal performance.
  stopRecognizeCount:

  This value reflects how long to wait after detecting non-human voice before concluding that the user has stopped speaking. It controls the gap between consecutive speech utterances. Within this gap, VAD will treat adjacent sentences as part of the same speech.
  A shorter gap will increase the likelihood of adjacent sentences being recognized as separate speech segments. Typically, it is recommended to set this value between 50 and 80.
  For example: "Good afternoon, [interval_between_sentences] what are some fun places to visit in Beijing?"

  If the interval_between_sentences between the speaker's phrases is greater than the stopRecognizeCount, the VAD will recognize the above as two separate VADs:

  VAD1: Good afternoon
  VAD2: What are some fun places to visit in Beijing?
  If the interval_between_sentences is less than stopRecognizeCount, the VAD will recognize the above as a single VAD:

  VAD: Good afternoon, what are some fun places to visit in Beijing?



  If latency is a concern, you can lower this value, or consult with the development team to determine how to manage latency while ensuring semantic continuity in speech recognition. This will help avoid the AI being interrupted too sensitively.


pkgId: 4e67d706f228b456d76f84922b8136ca93e2178c8e807293d8d9c94a0bb1a0f8
name: python-ahbicht-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for ahbicht
url: https://github.com/Hochfrequenz/ahbicht
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ahbicht-0.10.1-1.src.rpm
location_href: Packages/python-ahbicht-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
  |Unittests status badge| |Coverage status badge| |Linting status badge|
  |Black status badge| |pypy status badge|
  A python package that parses condition expressions from EDI\@Energy
  Anwendungshandbücher (AHB). Since it's based on lark, we named the
  module AHBicht.


pkgId: 0731d53ceeb53974f7e7366febb24c5e5f089c6f6735c180b000351f521d16be
name: python-ahclib-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for ahclib
url: https://github.com/titan-23/ahclib
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ahclib-0.1.0-1.src.rpm
location_href: Packages/python-ahclib-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  `titan23 <https://atcoder.jp/users/titan23?contestType=heuristic>`_  が使用している、AHC のツールです。
  ありえないバグがあるかもしれません。ご注意ください。
  `View on GitHub <https://github.com/titan-23/ahclib/tree/main>`_


pkgId: 29fa83ced2962c7d731487b5453d54f14a4d8f1b53649365b7a0e50b8314e3ea
name: python-ai-cloud-sdk-4pd-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for ai-cloud-sdk-4pd
url: https://gitlab.4pd.io/ai_clound_platform/4pd-ai-clound-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-cloud-sdk-4pd-0.1.5-1.src.rpm
location_href: Packages/python-ai-cloud-sdk-4pd-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  **AI云平台SDK**

  这是第四范式提供的AI云平台SDK。通过该sdk可以调用AI云平台提供的各种模型服务。



  ```shell
  pip install ai-cloud-sdk-4pd
  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models

  count = 0


  async def on_ready():
      print('ready')


  async def on_response(response):
      global count
      print('-------------------------------------')
      print(count)
      count += 1
      print(response)


  async def on_completed():
      print('completed')


  async def test_asr():
      print('-------------test asr-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.ASRRequest(
          audio_url='your local audio path',
          language='ja',
      )

      await client.asr_ws_send(
          request=request,
          on_ready=on_ready,
          on_response=on_response,
          on_completed=on_completed,
      )
      print('---------------------------------')


  if __name__ == '__main__':
      import asyncio

      asyncio.get_event_loop().run_until_complete(test_asr())


  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models


  def test_detection():
      print('-------------test detection-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.AudioLanguageDetectionRequest(
          audio='your local audio path',
          metadata='zh',
      )
      response = client.send(request=request)
      print(response.code)
      print(response.data)
      print(response.message)
      print('-------------------------------------')


  if __name__ == '__main__':
      test_detection()

  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models


  def test_tts():
      print('-------------test client-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.TTSRequest(
          transcription='你好啊,我是张三',
          language='zh',
          voice_name='zh-f-sweet-2',
      )
      response = client.tts(request=request)
      
      print(response.content)


  if __name__ == '__main__':
      test_tts()

  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models


  def test_translate():
      print('-------------test client-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.TranslateTextRequest(
          text=["hfdih"],
          source="en",
          target="zh",
      )
      response = client.translate_text(request=request)
      print(request.payload)
      print(response.code)
      print(response.data)
      print(response.message)
      print('-------------------------------------')


  if __name__ == '__main__':
      test_translate()

  ```


pkgId: df1eba0d7a16af2a160974f5eb0f90448292027fe2c2b7a11f15f839f0ee972b
name: python-ai-cloud-sdk-4pd-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for ai-cloud-sdk-4pd
url: https://gitlab.4pd.io/ai_clound_platform/4pd-ai-clound-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-cloud-sdk-4pd-0.1.6-1.src.rpm
location_href: Packages/python-ai-cloud-sdk-4pd-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  **AI云平台SDK**

  这是第四范式提供的AI云平台SDK。通过该sdk可以调用AI云平台提供的各种模型服务。



  ```shell
  pip install ai-cloud-sdk-4pd
  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models

  count = 0


  async def on_ready():
      print('ready')


  async def on_response(response):
      global count
      print('-------------------------------------')
      print(count)
      count += 1
      print(response)


  async def on_completed():
      print('completed')


  async def test_asr():
      print('-------------test asr-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.ASRRequest(
          audio_url='your local audio path',
          language='ja',
      )

      await client.asr_ws_send(
          request=request,
          on_ready=on_ready,
          on_response=on_response,
          on_completed=on_completed,
      )
      print('---------------------------------')


  if __name__ == '__main__':
      import asyncio

      asyncio.get_event_loop().run_until_complete(test_asr())


  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models


  def test_detection():
      print('-------------test detection-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.AudioLanguageDetectionRequest(
          audio='your local audio path',
          metadata='zh',
          choices=['zh', 'en'],
      )
      response = client.audio_language_detection(request=request)
      print(response.code)
      print(response.data)
      print(response.message)
      print('-------------------------------------')


  if __name__ == '__main__':
      test_detection()

  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models


  def test_tts():
      print('-------------test client-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.TTSRequest(
          transcription='你好啊,我是张三',
          language='zh',
          voice_name='zh-f-sweet-2',
      )
      response = client.tts(request=request)
      
      print(response.content)


  if __name__ == '__main__':
      test_tts()

  ```



  ```python

  import ai_cloud_sdk_4pd.client as ai_cloud_sdk_4pd_client
  import ai_cloud_sdk_4pd.models as ai_cloud_sdk_4pd_models


  def test_translate():
      print('-------------test client-------------')
      token = 'your token'
      call_token = 'your call token'
      region = 'China'
      config = ai_cloud_sdk_4pd_models.Config(
          token=token,
          call_token=call_token,
          region=region,
      )
      client = ai_cloud_sdk_4pd_client.Client(config=config)
      request = ai_cloud_sdk_4pd_models.TranslateTextRequest(
          text=["hfdih"],
          source="en",
          target="zh",
      )
      response = client.translate_text(request=request)
      print(request.payload)
      print(response.code)
      print(response.data)
      print(response.message)
      print('-------------------------------------')


  if __name__ == '__main__':
      test_translate()

  ```


pkgId: facb504ed74b779508de2a4f87a81e559ce8ec70be5ba74ee01e2e987d043e04
name: python-ai-data-science-team-help
arch: noarch
version: 0.0.0.9000
epoch: 0
release: 1
summary: Development documents and examples for ai-data-science-team
url: https://github.com/business-science/ai-data-science-team
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-data-science-team-0.0.0.9000-1.src.rpm
location_href: Packages/python-ai-data-science-team-help-0.0.0.9000-1.noarch.rpm
checksum_type: sha256
description:
      * CREATE DATA CLEANER CODE
      * EXECUTING AGENT CODE
      * EXPLAIN AGENT CODE
  ```

  1. Fork the repository
  2. Create a feature branch
  3. Commit your changes
  4. Push to the branch
  5. Create a Pull Request

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


pkgId: 1d5563e192b22e24c40b451ce84492495464b8f76499c6f11027d16b3ff1a647
name: python-ai-edge-litert-nightly
arch: noarch
version: 1.0.1.dev20241213
epoch: 0
release: 1
summary: LiteRT is for mobile and embedded devices.
url: https://www.tensorflow.org/lite/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-edge-litert-nightly-1.0.1.dev20241213-1.src.rpm
location_href: Packages/python-ai-edge-litert-nightly-1.0.1.dev20241213-1.noarch.rpm
checksum_type: sha256
description:
  LiteRT is the official solution for running machine learning models on mobile
  and embedded devices. It enables on-device machine learning inference with low
  latency and a small binary size on Android, iOS, and other operating systems.


pkgId: 443967d64333d4125534e1ec07feebc627264060f80b671ce0f72cf8d7c58a67
name: python-ai-git-utils-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for ai-git-utils
url: https://github.com/twn39/aigit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-git-utils-0.2.6-1.src.rpm
location_href: Packages/python-ai-git-utils-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  AI git utils is an intelligent Git commit assistant that leverages AI to enhance your Git workflow.
  It provides smart commit message generation and emoji selection to make your version control process more efficient and expressive.


  ![](https://raw.githubusercontent.com/twn39/aigit/main/screen.png)



  - AI-powered commit message generation
  - Interactive emoji selection for commit messages
  - Multiple AI model support with easy configuration



  ```bash
  pip install ai-git-utils
  ```



  Generate AI-assisted commit message

  ```
  aigit commit
  ```

  Check the help

  ```
  aigit --help
  ```


pkgId: 7fab2e189e0df297cd29664eb1edd991e22b6fe477cb12282e411207bf9e5bcb
name: python-ai-signal-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for ai-signal
url: https://github.com/guglielmo/ai-signal
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-signal-0.7.0-1.src.rpm
location_href: Packages/python-ai-signal-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  ![AI Signal Terminal](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/main.png)

  Terminal-based AI curator that turns information noise into meaningful signal.

  AI Signal is a powerful tool designed to help you regain control over your information diet in today's
  overwhelming digital landscape. While existing platforms and algorithms decide what content reaches you,
  AI Signal empowers you to define and implement your own content curation strategy.

  By leveraging AI capabilities and your personal preferences, it transforms the constant
  stream of information into meaningful, relevant insights that matter to you.
  You define the categories, quality thresholds, and filtering criteria, ensuring that the content you consume
  aligns with your interests and goals.

  Think of it as your personal content curator that works tirelessly to surface valuable information
  while filtering out noise, all running locally on your machine.
  With AI Signal, you're not just consuming content – you're actively shaping how information reaches you,
  making conscious choices about what deserves your attention.



  - 🤖 AI-powered content analysis and categorization
  - 🔍 Smart filtering based on customizable categories and quality thresholds
  - 📊 Advanced sorting by date, ranking, or combined criteria
  - 🔄 Automatic content synchronization from multiple sources
  - 🌐 Support for various content sources (YouTube, Medium, Reddit, Hacker News, RSS feeds)
  - 📱 Share curated content directly to social media
  - 📝 Export to Obsidian vault with customizable templates
  - ⌨️ Fully keyboard-driven interface
  - 🎨 Beautiful terminal UI powered by Textual



  ```bash
  pip install ai-signal
  ```

  or
  ```bash
  pipx install ai-siganl
  ```
  for global installation.


  If using poetry:

  ```bash
  poetry add ai-signal
  poetry shell # enter the virtualenv
  ```



  1. Create a configuration file:
  ```bash
  aisignal init
  ```
  modify it, as described in the [configuration guide](docs/configuration.md):

  2. Run AI Signal:
  ```bash
  aisignal run
  ```




  - `q`: Quit application
  - `c`: Toggle configuration panel
  - `s`: Force sync content
  - `f`: Toggle filters sidebar
  - `u`: Show usage and costs modal


  - `↑`/`↓`: Navigate items
  - `enter`: Show item details
  - `o`: Open in browser
  - `t`: Share on Twitter
  - `l`: Share on LinkedIn
  - `e`: Export to Obsidian





  ![Main Interface](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/main.png)


  ![Configuration Interface](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/configuration.png)


  ![Resource Detail Interface](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/detail.png)


  ![Sidebar hidden](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/sidebar_hidden.png)


  ![Tokens modal](https://raw.githubusercontent.com/guglielmo/ai-signal/main/docs/images/tokens_modal.png)



  This project is in its early development stages.
  I am not yet ready to provide a working prototype. As an open source initiative, I welcome contributors
  who can help advance the project. Please read the [Contributing Guide](CONTRIBUTING.md)




  ```bash

  git clone https://github.com/guglielmo/ai-signal.git
  cd ai-signal


  poetry install


  poetry run pytest


  poetry run aisignal version
  ```

  or, entering the virtualenv:

  ```bash
  poetry shell
  aisignal version
  ```



  - [ ] Add support for more content sources (YT videos, podcasts, pdf)
  - [ ] Add statistics on most used sources and categories
    - which are the sources most interesting news come from?
    - which are the categories with most news
    - which are the trends
  - [ ] Implement a double thresholds mechanism
    - all below minimal threshold is not even added to the datatable
    - all below maximum threshold is accepted as _interesting_
    - all in between must be further evaluated, by you, with your keyboard
      - y - accept
      - n - refuse
  - [ ] Implement feedback loop, based on your selections
    - suggest other interests that you may have
    - highlight waning interests
  - [ ] Implement custom AI models (Anthropic, Ollama, Gemini, ...)
  - [ ] Add content archiving
    - read/unread items, filter by read/unread status
    - remove items
  - [ ] Enable custom prompts for sources
  - [ ] Enable custom filtering rules



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



  - Built with [Textual](https://github.com/Textualize/textual)
  - AI powered by OpenAI and Jina AI
  - Inspired by Daniel Miessler's [Fabric](https://github.com/danielmiessler/fabric)



  **Guglielmo Celata**
  - GitHub: [@guglielmo](https://github.com/guglielmo)
  - Mastodon: [@guille@mastodon.uno](https://mastodon.uno/@guille)


pkgId: a0c814c08aa02598510c87320407e2c2a7c8e397fcc0f1ab3ab78170d222caa6
name: python-ai-stepper-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for ai-stepper
url: https://github.com/alfredwallace7/ai-stepper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-stepper-0.1.4-1.src.rpm
location_href: Packages/python-ai-stepper-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  A lightweight, flexible Python framework for creating step-by-step AI workflows with full LLM prompt control.



  AI Stepper is a basic sequential AI agent system designed for developers who need:
  - Full control over LLM prompts and interactions
  - Step-by-step workflow execution
  - Strong output validation
  - Simple retry mechanisms
  - Clear and predictable agent behavior

  If you're looking for a straightforward way to create sequential AI workflows without the complexity of full-scale agent frameworks, AI Stepper is the right choice.



  - **LLM Agnostic**: Works with any LLM through litellm annotations (OpenAI, Anthropic, local models, etc.)
  - **Wide Compatibility**: Compatible with LLMs that don't support function calling.
  - **Full Prompt Control**: Define exactly how your LLM should behave at each step
  - **Sequential Execution**: Each step's output is automatically available as input for subsequent steps
  - **YAML-Driven Workflows**: Define your entire workflow in a simple YAML file
  - **Schema Compatibility**: Supports both JSON Schema and YAML annotations for input/output validation
  - **Strong Validation**: Validate LLM outputs against predefined schemas
  - **Rich Logging**: Built-in Markdown-formatted logging with step context
  - **Flexible Callbacks**: Custom callback system for monitoring and debugging



  ```bash
  pip install -U ai-stepper
  ```




  Create a `.env` file with your LLM configuration:

  ```env
  OPENAI_API_BASE=your_llm_api_base
  OPENAI_API_KEY=your_llm_api_key
  OPENAI_MODEL_NAME=your_model_name
  ```


  Define your workflow steps in a YAML file (e.g., `chain_of_thoughts.yaml`):

  ```yaml
  direct_answer:
    task: >
      {query}
    inputs:
      query:
        type: string
    outputs:
      final_answer:
        type: string

  define_problem:
    task: >
      Break down the problem statement {query} into its core components. Identify what needs to be solved or answered and
      list these subproblems explicitly.
    inputs:
      query:
        type: string
    outputs:
      subproblems:
        type: array
        items:
          type: string

  generate_subsolutions:
    task: >
      Solve each subproblem {subproblems} step by step. For each subproblem, provide a concise solution or analysis.
      If the subproblem cannot be solved directly, explain why.
    inputs:
      subproblems:
        type: array
        items:
          type: string
    outputs:
      subsolutions:
        type: array
        items:
          type: object
          properties:
            subproblem:
              type: string
            solution:
              type: string

  combine_results:
    task: >
      Combine the solutions to the subproblems {subsolutions} into a coherent final answer to the original query.
      Ensure the reasoning flows logically, and the answer directly addresses the query.
    inputs:
      subsolutions:
        type: array
        items:
          type: object
          properties:
            subproblem:
              type: string
            solution:
              type: string
    outputs:
      final_answer:
        type: string
  ```


  Create a Python script to run your workflow:

  ```python
  from ai_stepper import AI_Stepper
  import os
  from dotenv import load_dotenv
  from rich import print
  from typing import Optional
  from datetime import datetime


  load_dotenv(override=True)

  def agent_logger(message: str, step_name: Optional[str] = None):
      """Log agent actions and responses."""
      if step_name:
          print(f"\n### {step_name.upper()}\n{message}\n")
      else:
          print(f"\n{message}\n")

  def run_workflow(stepper: AI_Stepper, name: str, yaml_file: str, inputs: dict) -> None:
      """Run a single workflow and handle any errors."""
      try:
          print(f"\n[bold blue]Running {name} workflow...[/bold blue]")
          result = stepper.run(
              steps_file=yaml_file,
              initial_inputs=inputs,
              callback=agent_logger
          )
          print(f"[green]Result:[/green]", result)
      except Exception as e:
          print(f"[bold red]Error in {name} workflow:[/bold red] {str(e)}")

  def main():
      """Main execution function."""
      try:
          
          stepper = AI_Stepper(
              llm_base_url=os.getenv("OPENAI_API_BASE"),
              llm_api_key=os.getenv("OPENAI_API_KEY"),
              llm_model_name=os.getenv("OPENAI_MODEL_NAME")
          )

          
          workflows = [
              ("Chain of Thoughts", "yaml/chain_of_thoughts.yaml", {
                  "query": "A farmer has 20 apples. He gives 5 apples to his neighbor and then splits the remaining apples equally among his 3 children. How many apples does each child get?"
              }),
          ]

          for name, yaml_file, inputs in workflows:
              run_workflow(stepper, name, yaml_file, inputs)

      except Exception as e:
          print(f"[bold red]Critical error:[/bold red] {str(e)}")

  if __name__ == "__main__":
      main()
  ```

  This example demonstrates a workflow that:
  1. Breaks down the question into subproblems
  2. Solves each subproblem step by step
  3. Combines the solutions into a final answer

  The framework handles:
  - Environment configuration
  - YAML workflow loading
  - Step execution
  - Error handling
  - Logging
  - Output validation

  For more examples, check the `yaml/` directory in the repository.





  AI Stepper includes a built-in markdown logger utility that creates well-formatted logs of your workflow execution. The logger supports:

  - Timestamped entries with timezone support
  - Structured message formatting
  - Code block formatting with syntax highlighting
  - Token usage tracking
  - JSON pretty-printing
  - File output capabilities

  Example usage:

  ```python
  from ai_stepper.utils.logger import markdown_logger
  from ai_stepper.schema.callback import CallBack


  callback = CallBack(
      sender="LLM",
      step_name="analyze_sentiment",
      object="output",
      message="Response for sentiment analysis",
      created=int(datetime.utcnow().timestamp()),
      code=CodeItem(
          language="json",
          content={"sentiment_analysis": {"product_sentiments": [...]}}
      )
  )


  markdown_logger(callback, "log.md")
  ```



  AI Stepper enforces strict schema validation for LLM outputs. Each step's output must conform to the schema defined in your YAML workflow:

  ```yaml
  analyze_sentiment:
    task: >
      Perform sentiment analysis on the feedback {feedback}.
      Determine whether each theme has a positive, negative, or neutral sentiment.
    inputs:
      feedback:
        type: array
    outputs:
      sentiment_analysis:
        type: object
        properties:
          product_sentiments:
            type: array
            items:
              type: object
              properties:
                product:
                  type: string
                theme_sentiments:
                  type: array
                  items:
                    type: object
                    properties:
                      theme:
                        type: string
                      sentiment:
                        type: string
  ```

  The framework will:
  1. Validate all outputs against their schemas
  2. Provide clear error messages for validation failures
  3. Support retry mechanisms for failed validations
  4. Log validation results in markdown format



  Contributions are welcome! Please feel free to submit a Pull Request.



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


pkgId: 3efa49fd6634a66c1d56b631db7f74f8df01eec551da3088b2bafa05986ecea4
name: python-ai-vocabulary-builder-help
arch: noarch
version: 0.8.2
epoch: 0
release: 1
summary: Development documents and examples for ai-vocabulary-builder
url: https://pypi.org/project/ai-vocabulary-builder/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-vocabulary-builder-0.8.2-1.src.rpm
location_href: Packages/python-ai-vocabulary-builder-help-0.8.2-1.noarch.rpm
checksum_type: sha256
description:
  AI 生词本（“AI Vocabulary Builder” 简称 aivoc）是一个利用了 AI 技术的智能生词本工具，它能帮你快速构建起自己的生词库，学习起来事半功倍。

  核心功能：

  - 提供高质量的整句翻译能力
  - 由 AI 自动提取生词及释义
  - 独创的故事模式助记生词
  - 支持 CSV 等格式导出生词本

  工具截图：

  <img width="742" alt="image" src="https://github.com/piglei/ai-vocabulary-builder/assets/731266/f02a43ec-71f7-43c4-a5ec-26e74f3b158d">

  ↑ Web App “笔记本”模式

  <img width="742" alt="image" src="https://user-images.githubusercontent.com/731266/224582400-56e66b81-3368-42b6-885f-74a6be160edb.png">

  ↑ 交互式翻译，自动提取生词

  <img width="742" alt="image" src="https://user-images.githubusercontent.com/731266/224582444-49555765-014c-457c-a83c-72c44e9fe3c5.png">

  ↑ 通过阅读故事，牢固掌握生词



  本工具基于 Python 开发，请使用 pip 来安装本工具：

  ```console

  pip install ai-vocabulary-builder
  ```

  安装完成后，请在环境变量中设置你的 [OpenAI API key](https://platform.openai.com/account/api-keys)：

  ```console

  export OPENAI_API_KEY='your_api_key'
  ```

  之后执行 `aivoc run` 启动工具，进入交互式命令行模式。或者执行 `aivoc notebook`，在浏览器中打开可交互式 Web App（推荐）。

  除环境变量外，你也可以通过 `--api-key` 参数完成设置：

  ```console
  aivoc run --api-key "your_api_key"
  ```





  执行 `aivoc notebook` 命令，使用可交互式 Web App。



  执行 `aivoc run` 命令，会进入交互式命令行模式，在该模式下，你可以快速完成添加生词、阅读故事等操作。



  默认情况下，命令行处于“添加生词”模式，此时你可以直接粘贴一小段英文：

  ```console
  Enter text> It depicted simply an enormous face, more than a metre wide
  ```

  按下回车后，工具会开始翻译工作。它首先会将你所输入内容的中文翻译打印到屏幕上。然后，它会从原文中提取出一个**你最有可能不认识的单词**，将其加入到生词本中。

  ```
                                Translation Result
  ┌───────────────┬─────────────────────────────────────────────────────────────┐
  │ Original Text │ It depicted simply an enormous face, more than a metre wide │
  │ Translation   │ 它只是简单地描绘了一个巨大的面孔，超过一米宽。              │
  └───────────────┴─────────────────────────────────────────────────────────────┘


  ⠴  Extracting word
  > The new word AI has chosen is "depicted".

  ┏━━━━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃ Word     ┃ Pronunciation ┃ Definition                 ┃
  ┡━━━━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
  │ depicted │ /dɪˈpɪkt/     │ 描述，描绘（原词：depict） │
  └──────────┴───────────────┴────────────────────────────┘
  "depicted" was added to your vocabulary book (78 in total), well done!
  ```



  某些情况下，工具所挑选的生词可能并非你所想的那个。此时，通过输入 `no` 命令，你可以启动一次重选：

  ```
  Enter text> no
  ```

  上一次被添加到生词本的单词会被丢弃，工具将尝试重新返回 4 个新生词（可能包含刚被丢弃的词），如下所示：

  ```
  "depicted" has been discarded from your vocabulary book.
  ⠋  Extracting multiple new words
  ? Choose the word(s) you don't know (Use arrow keys to move, <space> to select, <a> to toggle, <i> to invert)
   » ○ depicted / （原词：depict） / dɪˈpɪkt / 描绘，描述
     ○ metre / （原词：meter） / ˈmiːtə(r) / 米
     ○ simply / ˈsɪmpli / 简而言之，仅仅
     ○ enormous / ɪˈnɔːməs / 巨大的，庞大的
     ○ None of above, skip for now.
  ```

  请按↑↓方向键移动游标，按空格选中你想要的词（支持多选），按下回车确认。选中的单词会被添加到你的生词本中。

  ```
  ? Choose the word(s) you don't know done (2 selections)
  New word(s) added to your vocabulary book: "metre,enormous" (79 in total), well done!
  ```

  假如你所想的单词仍然没有出现在选项中，请选择 `None of above, skip for now.`，跳过本次添加。

  > 别气馁，祝你下次好运。😁



  使用 `list` 命令可以查看生词本中最近添加的生词，默认展示 10 条：

  ```plain
  Enter text> list
  ```

  该命令接收一个可选参数：`limit`，用来指定生词的数量。常见用法：

  ```plain

  Enter text> list 5

  Enter text> list all
  ```



  使用 `remove` 命令可以进入“删除生词”模式。

  <img width="709" alt="image" src="https://user-images.githubusercontent.com/731266/229272715-4e7ba4e2-6c2e-434f-8d84-ca0f2373de04.png">

  在该模式下，你可以输入单词（按↑↓方向键选择自动补全），再按回车键将其从生词本中删除。除手动输入外，你还用可以用鼠标选择单词。

  要退出“删除生词”模式，输入 q （或不输入任何内容）按下回车，工具将退回到“翻译模式”。



  为了快速并牢固掌握生词本里的单词，本工具提供了一个创新的故事模式。在交互式命令行模式下，输入 `story` 开始故事模式：

  ```
  Enter text> story
  ```

  工具将从生词本里挑选出 6 个单词，请求 AI 用这些词写一个小故事。输入如下所示：

  ```
  Words for generating story: prudent, extraneous, serendipitously, onus, aphorisms, cater
  ⠼  Querying OpenAI API to write the story...
  ╭─────────────────────────────────────────── Enjoy your reading ────────────────────────────────────────────╮
  │ Once there was a prudent young girl named Alice who always carried a small notebook with her. She wrote   │
  │ down aphorisms and wise sayings that she heard from her elders or from books. It was an extraneous task,  │
  │ but Alice believed that it helped her to be wise and joyful.                                              │
  │                                                                                                           │
  │ One day, Alice went for a walk in the park and serendipitously met an old man. He was reading a book, and │
  │ Alice noticed that he had marked some phrases with a pencil. She greeted him and asked about the book.    │
  │ They started to chat about literature, and the man shared some of his favorite aphorisms.                 │
  │                                                                                                           │
  │ Alice was delighted, and she wrote down the new sayings in her notebook. After their conversation, the    │
  │ man thanked Alice and said that he felt as if a heavy onus had been lifted from his chest. Alice smiled   │
  │ and said that it was her pleasure to cater to his needs.                                                  │
  │                                                                                                           │
  │ From then on, Alice and the old man often met in the park to exchange knowledge and wisdom. They learned  │
  │ that serendipity could bring unexpected blessings to life.                                                │
  ╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```

  阅读结束后，按下回车键，你可以继续查看在故事中出现的所有生词的详细信息。





  你可以使用 `export` 命令来导出你的生词本。以下是一些示例：

  ```

  aivoc export

  aivoc export --format csv

  aivoc export --format csv --file-path ./voc.csv
  ```



  如果你觉得你已经牢牢掌握了某个生词，你可以将它从生词本里删除。执行 `remove` 命令来完成这个任务：

  ```console

  aivoc remove enormous depicted
  ```



  此处列举了本工具的所有**全局配置项**。目前仅支持通过环境变量来完成配置，未来将增加对配置文件的支持。

  > 如果你想了解各子命令支持哪些个性化参数，比如“导出”支持哪些格式和参数，请使用 `--help` 参数，比如：`aivoc export --help`。



  工具调用 OpenAI 的 API 时所使用的 [API Key](https://platform.openai.com/account/api-keys)，必须设置。

  示例：

  ```
  export OPENAI_API_KEY='your_api_key'
  ```



  工具所使用的 OpenAI 的 API 地址，可选设置。仅当默认 API 地址（`https://api.openai.com/v1`）无法正常访问时指定。

  示例：

  ```bash

  export OPENAI_API_BASE="https://www.my-openai-proxy.com/v1"
  ```

  💡 请关注地址配置中的 `/v1` 部分。是否添加它，取决于你的代理配置如何。不确定的话可以先写上，如果无法成功调用，再去掉 `/v1` 试试看。



  指定生词本储存数据文件的路径, 默认路径为当前登录用户的 home 目录: `~/`

  示例：

  ```
  export AIVOC_DATA_DIR="$HOME/Documents"
  ```



  学习一门语言，生词本是一个非常重要的工具。一个内容优秀的生词本，至少需要包含：**生词、释义、例句、例句释义**这些内容。但是，手动维护这些内容非常麻烦，因此大部分人都没有自己的生词本。阅读时碰见生词，常常查过词典，转头就忘。

  “AI 生词本”尝试着使用 ChatGPT 的能力，将生词本的维护成本降到最低，让每人都可以拥有自己的生词本。



  - 支持 [bob-plugin-openai-translator](https://github.com/yetone/bob-plugin-openai-translator) 插件，实现划词自动扩充生词本。


pkgId: 80bb8ac9d9760f9289be645b09375106fe92c4483df21c00b98abca96aba51c3
name: python-ai-vocabulary-builder-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for ai-vocabulary-builder
url: https://pypi.org/project/ai-vocabulary-builder/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-vocabulary-builder-1.2.2-1.src.rpm
location_href: Packages/python-ai-vocabulary-builder-help-1.2.2-1.noarch.rpm
checksum_type: sha256
description:
  > Available in other languages: [[中文]](docs/README_zh.md)

  "AI-Voc Builder" is a smart English vocabulary tool powered by AI technology. It helps you quickly build your own English vocabulary and learn more effectively.

  Key Features:

  - Unique, efficient vocabulary building: **One-click** saving of sample sentences, translations, new words, and definitions.
  - Engaging **story and quiz modes** to help you master new words.
  - Supports **over 10 target languages** with multiple AI backends, including OpenAI, Gemini, and Anthropic.

  Product Screenshots:

  <div align="center">
    <table>
      <tr>
        <td align="center">
          <a href="https://github.com/user-attachments/assets/5f45a172-bb01-4277-81e4-68e3381d2113" target="_blank">
            <img src="https://github.com/user-attachments/assets/5f45a172-bb01-4277-81e4-68e3381d2113" style="max-height: 200px;">
          </a>
          <br>↑ AI-Powered Smart Vocabulary Extraction
        </td>
        <td align="center">
          <a href="https://github.com/user-attachments/assets/bdfe9802-bccc-4d85-9fc5-09829a20bbcc" target="_blank">
            <img src="https://github.com/user-attachments/assets/bdfe9802-bccc-4d85-9fc5-09829a20bbcc" style="max-height: 200px;">
          </a>
          <br>↑ Test Mode for Enhanced Memorization
        </td>
      </tr>
    </table>
  </div>



  This tool is developed using Python. Please use `pip` or other packaging tools to install it:

  ```bash
  pip install ai-vocabulary-builder
  ```

  [pipx](https://github.com/pypa/pipx)

  ```bash
  pipx install ai-vocabulary-builder
  ```

  [uv](https://github.com/astral-sh/uv)

  ```bash
  uv pip install ai-vocabulary-builder


  ```

  > Requires Python version 3.9 or higher.

  After installation, run `aivoc notebook` to open the application in your browser.



  The most commonly used features can be found inside the notebook app. Here are some more advanced features:

  - Integration with [PopClip](https://www.popclip.app/) to add new words by highlighting. [Read Guide](docs/integrations.md)



  The main configurations for this tool can be managed from the web page. Here are some additional configurations that are set through environment variables.



  Specifies the path where the vocabulary data files are stored. The default path is the current user's home directory: ~/.

  Example:

  ```
  export AIVOC_DATA_DIR="$HOME/Documents"
  ```



  When learning English, a vocabulary builder is a very important tool. A good vocabulary builder should include at least the following: **new words, definitions, example sentences, and example sentence translations** . However, maintaining this information manually is very tedious. As a result, most people who have studied English for many years do not have their own vocabulary builder. They often encounter new words while reading, look them up in the dictionary, and then forget them 20 seconds later.

  "AI-Voc Builder" tries to use the power of AI to make the process of building a vocabulary builder easy and fun, so that everyone can have their own vocabulary builder and quickly expand their vocabulary.


pkgId: 8a519391e9adca9379b8bc926b075e5658fbfb85e114a2cce1f425186fc8ccc1
name: python-ai-wallpaper-help
arch: noarch
version: 0.1.dev19
epoch: 0
release: 1
summary: Development documents and examples for ai-wallpaper
url: https://github.com/debanjum/ai-wallpaper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai-wallpaper-0.1.dev19-1.src.rpm
location_href: Packages/python-ai-wallpaper-help-0.1.dev19-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
     <h1 align="center">✨ AI Wallpaper</h1>
  </p>
  <p align="center">
     <a href="https://github.com/khoj-ai/khoj"><img src="https://badgen.net/badge/powered by/%E2%9C%A8khoj%20ai/27c2d8/" /></a>
     <a href="LICENSE"><img src="https://badgen.net/github/license/debanjum/ai-wallpaper" /></a>
     <a href="https://pypi.org/project/ai-wallpaper/"><img src="https://badge.fury.io/py/ai-wallpaper.svg" /></a>
  </p>

  <p align="center">
     Get fresh, personal AI painted wallpapers daily
  </p>


  - Get fresh, personal wallpapers painted for you by [khoj ai](https://github.com/khoj-ai/khoj)
  - Automatically weaves your current city, moon phase, weather and (even recent experiences!) into the painting
  - Updates your Android or Mac wallpaper automatically
  - Schedule it to run every day and night
  - Customize the wallpapers by telling khoj what styles and information to use



  - Generate a (free) [Khoj API Key](https://app.khoj.dev/config#clients) or [setup a self-hosted Khoj](https://docs.khoj.dev/get-started/setup/)
  - Install [Termux](https://f-droid.org/en/packages/com.termux/) to use on Android
  - Requires a Mac or Android Operating System. *Windows, Linux support if enough demand*


  ```shell
  pip install ai-wallpaper && KHOJ_API_KEY=<YOU_KHOJ_API_KEY> aiwall
  ```


  | Day | Night |
  |-----|-------|
  | ![](./assets/ai_wallpaper_4.jpg) | ![](./assets/ai_wallpaper_1.jpg) |
  | ![](./assets/ai_wallpaper_5.jpg) | ![](./assets/ai_wallpaper_2.jpg) |
  | ![](./assets/ai_wallpaper_6.jpg) | ![](./assets/ai_wallpaper_3.jpg) |

  https://github.com/debanjum/ai-wallpaper/assets/6413477/823c1624-6452-472e-8786-4cb79bcfa029




    ```shell
     KHOJ_API_KEY=<YOUR_KHOJ_API_KEY> aiwall
    ```


    ```shell
     KHOJ_API_KEY=<YOUR_KHOJ_API_KEY> aiwall "Generate a wallpaper based on the latest news here"
    ```


    ```shell
     KHOJ_API_KEY=<YOUR_KHOJ_API_KEY> WALLPAPER_PATH="~/Pictures/wallpaper.png" aiwall
    ```


    ```shell
     KHOJ_HOST="http://localhost:42100" aiwall
    ```



    - Create a simple shell script to call the AI wallpaper creation command
      ```shell
       echo "#!/bin/sh\nKHOJ_API_KEY=<YOUR_KHOJ_API_KEY> aiwall" > wallpaper.sh
       chmod +x wallpaper.sh
      ```
    - On Android: Use [termux-job-scheduler](https://wiki.termux.com/wiki/Termux:API#:~:text=termux-job-scheduler) on Termux to get yourself a fresh and personal wallpaper painted every 12 hours
      ```shell
       
       pkg install termux-job-scheduler
       
       termux-job-scheduler -s aiwall --period-ms 43200000 --persisted true
       
       
      ```
      Note: *You can use [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm&hl=en&gl=US) + [Termux:Tasker](https://wiki.termux.com/wiki/Termux:Tasker) or other automations apps to trigger the Wallpaper script as well*
    - On Mac: Use Cron to get yourself a fresh and personal wallpaper painted every 12 hours
      ```shell
       
       crontab -e

       
       

       
       
      ```


  The AI wallpaper script can automatically incorporate any recent experiences from your notes into it's paintings. To use this you will need to sync your notes with Khoj.




  1. Download and Install
     ```shell
      
      git clone https://github.com/debajum/ai-wallpaper

      
      cd ai-wallpaper && pip install .
     ```

  2. Edit application

  3. Run any of the following commands to paint using your updated application
     ```shell
     
     KHOJ_API_KEY=<YOUR_KHOJ_API_KEY> python src/aiwall/paper.py

     
     KHOJ_API_KEY=<YOUR_KHOJ_API_KEY> python src/aiwall/paper.py "Generate a wallpaper based on the latest news here"

     
     KHOJ_API_KEY=<YOUR_KHOJ_API_KEY> WALLPAPER_PATH="~/Pictures/wallpaper.png" python src/aiwall/paper.py

     
     KHOJ_HOST="http://localhost:42100" python src/aiwall/paper.py
     ```


  This program is free software; it is distributed under the GNU General Public License v3.

  [GPLv3](LICENSE) © debanjum


pkgId: 260466ec2e0f5b69c28ba4b4083ebc564c374062bddc0b1790d4dd4ca2990226
name: python-ai2-olmo-eval-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for ai2-olmo-eval
url: https://github.com/allenai/OLMo-in-loop-evals
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai2-olmo-eval-0.3.0-1.src.rpm
location_href: Packages/python-ai2-olmo-eval-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Code for in-loop evaluation tasks used by the OLMo training team.



  ```
  pip install ai2-olmo-eval
  ```

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


pkgId: 1b041390193dc0c06d3c7e454bda95e281a115680cc8d0273ab44ab58b438a89
name: python-ai2-olmo-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for ai2-olmo
url: https://github.com/allenai/OLMo
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ai2-olmo-0.6.0-1.src.rpm
location_href: Packages/python-ai2-olmo-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <!-- <img src="https://github.com/allenai/OLMo/assets/8812459/774ac485-a535-4768-8f7c-db7be20f5cc3" width="300"/> -->
    <img src="https://allenai.org/olmo/olmo-7b-animation.gif" alt="OLMo Logo" width="800" style="margin-left:'auto' margin-right:'auto' display:'block'"/>
    <br>
    <br>
    <h1>OLMo: Open Language Model</h1>
  </div>
  <p align="center">
    <a href="https://github.com/allenai/OLMo/blob/main/LICENSE">
      <img alt="GitHub License" src="https://img.shields.io/github/license/allenai/OLMo">
    </a>
    <a href="https://github.com/allenai/OLMo/releases">
      <img alt="GitHub release" src="https://img.shields.io/github/release/allenai/OLMo.svg">
    </a>
    <a href="https://arxiv.org/pdf/2402.00838.pdf">
      <img alt="Paper URL" src="https://img.shields.io/badge/arxiv-2402.00838-blue">
    </a>
  </p>

  OLMo is a repository for training and using AI2's state-of-the-art open language models. It is designed by scientists, for scientists.



  First, install [PyTorch](https://pytorch.org) following the instructions specific to your operating system.

  For training and fine-tuning, we recommend installing from source:

  ```bash
  git clone https://github.com/allenai/OLMo.git
  cd OLMo
  pip install -e .[all]
  ```
  You can also install from PyPI with:
  ```bash
  pip install ai2-olmo
  ```



  OLMo pretraining follows a two-stage training procedure.
  In the first stage, we train on large amounts of mostly web-based data: [OLMo-mix-1124](https://huggingface.co/datasets/allenai/olmo-mix-1124)
  In the second stage, we train on a smaller amount of high-quality, targeted data: [Dolmino-mix-1124](https://huggingface.co/datasets/allenai/dolmino-mix-1124)

  You can find *all* the checkpoints, at minimum every 1000 training steps, on Huggingface:
   * [Huggingface for the 7B variant](https://huggingface.co/allenai/OLMo-2-1124-7B)
   * [Huggingface for the 13B variant](https://huggingface.co/allenai/OLMo-2-1124-13B)



  To reproduce any of the training processes described below, run this:

  ```bash
  torchrun --nproc_per_node=8 scripts/train.py {path_to_train_config}
  ```

  For the training config, use any of the configs listed below.

  If you want to override any of the settings in the training config without having to write a new config every time,
  you can do this:

  ```bash
  torchrun --nproc_per_node=8 scripts/train.py {path_to_train_config} \
    --setting1=value \
    --setting2=value \
    --setting3.subsetting1=value
  ```

  The training configs below refer to training data that gets streamed in live over HTTP.
  To reproduce at large scale, we recommend downloading the files locally and changing the paths to point to your
  local file system.

  *Note*: Some of the files that the training configs refer to are still being uploaded (as of 2024-11-27).
  They should all appear in the next few days as the uploads complete.



  Stage 1 is the biggest stage, where we train on 4T or 5T tokens on largely web-based data.

  |                 | OLMo2 7B                                                                                                          | OLMo2 13B                                                                                                          |
  |-----------------|-------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|
  | Number of tokens| 4 Trillion                                                                                                        | 5 Trillion                                                                                                         |
  | Checkpoint      | [stage1-step928646-tokens3896B](https://huggingface.co/allenai/OLMo-2-1124-7B/tree/stage1-step928646-tokens3896B) | [stage1-step596057-tokens5001B](https://huggingface.co/allenai/OLMo-2-1124-13B/tree/stage1-step596057-tokens5001B) |
  | Training config | [OLMo2-7B-stage1.yaml](configs/official-1124/OLMo2-7B-stage1.yaml)      | [OLMo2-13B-stage1.yaml](configs/official-1124/OLMo2-13B-stage1.yaml)     |
  | WandB           | wandb.ai/…/OLMo2-7B (link to come)                                                                                | wandb.ai/…/OLMo2-13B (link to come)                                                                                |



  For the 7B model, we train three times with different data order on 50B high quality tokens, and then average ("soup") the models.

  |                        | Checkpoint                                                                                                                          | Training config                                                                        | WandB       |
  |------------------------|-------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|-------------|
  | random seed 42         | [stage2-ingredient1-step11931-tokens50B](https://huggingface.co/allenai/OLMo-2-1124-7B/tree/stage2-ingredient1-step11931-tokens50B) | [OLMo2-7B-stage2-seed42.yaml](configs/official-1124/OLMo2-7B-stage2-seed42.yaml)       | link to come |
  | random seed 42069      | [stage2-ingredient2-step11931-tokens50B](https://huggingface.co/allenai/OLMo-2-1124-7B/tree/stage2-ingredient2-step11931-tokens50B) | [OLMo2-7B-stage2-seed42069.yaml](configs/official-1124/OLMo2-7B-stage2-seed42069.yaml) | link to come |
  | random seed 666        | [stage2-ingredient3-step11931-tokens50B](https://huggingface.co/allenai/OLMo-2-1124-7B/tree/stage2-ingredient3-step11931-tokens50B) | [OLMo2-7B-stage2-seed666.yaml](configs/official-1124/OLMo2-7B-stage2-seed666.yaml)     | link to come |
  | **final souped model** | [main](https://huggingface.co/allenai/OLMo-2-1124-7B/tree/main) | no config, we just averaged the weights in Python                                      | |

  The training configs linked here are set up to download the latest checkpoint after stage 1, and start training from there.



  For the 13B model, we train three times with different data order on 100B high quality tokens, and one more time
  on 300B high quality tokens. Then we average ("soup") the models.

  |                        | Checkpoint                                                                                                                             | Training config                                                                                  | WandB       |
  |------------------------|----------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------|-------------|
  | random seed 1110, 100B | [stage2-ingredient1-step11931-tokens100B](https://huggingface.co/allenai/OLMo-2-1124-13B/tree/stage2-ingredient1-step11931-tokens100B) | [OLMo2-13B-stage2-seed1110-100B.yaml](configs/official-1124/OLMo2-13B-stage2-seed1110-100B.yaml) | link to come |
  | random seed 2662, 100B | [stage2-ingredient2-step11931-tokens100B](https://huggingface.co/allenai/OLMo-2-1124-13B/tree/stage2-ingredient2-step11931-tokens100B) | [OLMo2-13B-stage2-seed2662-100B.yaml](configs/official-1124/OLMo2-13B-stage2-seed2662-100B.yaml) | link to come |
  | random seed 6209, 100B | [stage2-ingredient3-step11931-tokens100B](https://huggingface.co/allenai/OLMo-2-1124-13B/tree/stage2-ingredient3-step11931-tokens100B) | [OLMo2-13B-stage2-seed6209-100B.yaml](configs/official-1124/OLMo2-13B-stage2-seed6209-100B.yaml) | link to come |
  | random seed 2662, 300B | [stage2-ingredient4-step11931-tokens300B](https://huggingface.co/allenai/OLMo-2-1124-13B/tree/stage2-ingredient4-step35773-tokens300B) | [OLMo2-13B-stage2-seed2662-300B.yaml](configs/official-1124/OLMo2-13B-stage2-seed2662-300B.yaml) | link to come |
  | **final souped model** | [main](https://huggingface.co/allenai/OLMo-2-1124-13B/tree/main)                                                                       | no config, we just averaged the weights in Python                                                | |

  The training configs linked here are set up to download the latest checkpoint after stage 1, and start training from there.



  For instruction tuned variants of these models, go to
   * [OLMo2 7B Instruct](https://huggingface.co/allenai/OLMo-2-1124-7B-Instruct)
   * [OLMo2 13B Instruct](https://huggingface.co/allenai/OLMo-2-1124-13B-Instruct)



  You can use our Hugging Face integration to run inference on the OLMo Transformers checkpoints:

  ```python
  from transformers import AutoModelForCausalLM, AutoTokenizer
  olmo = AutoModelForCausalLM.from_pretrained("allenai/OLMo-2-1124-7B")
  tokenizer = AutoTokenizer.from_pretrained("allenai/OLMo-2-1124-7B")
  message = ["Language modeling is "]
  inputs = tokenizer(message, return_tensors='pt', return_token_type_ids=False)



  response = olmo.generate(**inputs, max_new_tokens=100, do_sample=True, top_k=50, top_p=0.95)
  print(tokenizer.batch_decode(response, skip_special_tokens=True)[0])
  ```

  Alternatively, with the Hugging Face pipeline abstraction:

  ```python
  from transformers import pipeline
  olmo_pipe = pipeline("text-generation", model="allenai/OLMo-2-1124-7B")
  print(olmo_pipe("Language modeling is"))
  ```



  ```python
  olmo = AutoModelForCausalLM.from_pretrained("allenai/OLMo-2-1124-7B", torch_dtype=torch.float16, load_in_8bit=True)  # requires bitsandbytes
  ```

  The quantized model is sensitive to input types and CUDA handling. To avoid potential issues, we recommend explicitly converting input IDs to CUDA using: `inputs.input_ids.to('cuda')`



  Additional tools for evaluating OLMo models are available at the [OLMo Eval](https://github.com/allenai/OLMo-eval) repo.



  ```bibtex
  @article{OLMo,
    title={OLMo: Accelerating the Science of Language Models},
    author={Dirk Groeneveld and Iz Beltagy and Pete Walsh and Akshita Bhagia and Rodney Kinney and Oyvind Tafjord and A. Jha and Hamish Ivison and Ian Magnusson and Yizhong Wang and Shane Arora and David Atkinson and Russell Authur and Khyathi Raghavi Chandu and Arman Cohan and Jennifer Dumas and Yanai Elazar and Yuling Gu and Jack Hessel and Tushar Khot and William Merrill and Jacob Daniel Morrison and Niklas Muennighoff and Aakanksha Naik and Crystal Nam and Matthew E. Peters and Valentina Pyatkin and Abhilasha Ravichander and Dustin Schwenk and Saurabh Shah and Will Smith and Emma Strubell and Nishant Subramani and Mitchell Wortsman and Pradeep Dasigi and Nathan Lambert and Kyle Richardson and Luke Zettlemoyer and Jesse Dodge and Kyle Lo and Luca Soldaini and Noah A. Smith and Hanna Hajishirzi},
    year={2024},
    url={https://api.semanticscholar.org/CorpusID:267365485},
    journal={arXiv preprint},
  }
  ```

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


pkgId: 72409b2ea9cf44aa1f7f2dacfc488b7c8d8aa03dd736a3a4324a7336eb448de7
name: python-aiXplain-help
arch: noarch
version: 0.2.24
epoch: 0
release: 1
summary: Development documents and examples for aiXplain
url: https://github.com/aixplain/aiXplain
rpm_license: Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiXplain-0.2.24-1.src.rpm
location_href: Packages/python-aiXplain-help-0.2.24-1.noarch.rpm
checksum_type: sha256
description:
  <img src="docs/assets/aixplain-brandmark-line.png" alt="aiXplain logo" title="aiXplain" align="right" height="132" width="85"/>



  aixplain is a software development kit (SDK) for the [aiXplain](https://aixplain.com/) platform. With aixplain, developers can quickly and easily:

  - [Discover](https://aixplain.com/platform/discovery/) aiXplain’s ever-expanding catalog of 35,000+ ready-to-use AI models and utilize them.
  - [Benchmark](https://aixplain.com/platform/benchmark/) AI systems by choosing models, datasets and metrics.
  - [Design](https://aixplain.com/platform/studio/) their own custom pipelines and run them.
  - [FineTune](https://aixplain.com/platform/finetune/) pre-trained models by tuning them using your data, enhancing their performance.

  🔎 **Find [models](https://platform.aixplain.com/discovery/models), [datasets](https://platform.aixplain.com/discovery/datasets), [metrics](https://platform.aixplain.com/discovery/metrics) on the platform.**

  💛 Our repository is constantly evolving. With the help of the scientific community, we plan to add even more datasets, models, and metrics across domains and tasks.




  To install the base package, simply,
  ```bash
  pip install aixplain
  ```

  To  install aiXplain with additional model building support:
  ```bash
  pip install aixplain[model-builder]
  ```


  Before you can use the aixplain SDK, you'll need to obtain an API key from our platform. For details refer this [Team API Key Guide](docs/user/api_setup.md).

  Once you get the API key, you'll  need to add this API key as an environment variable on your system.


  ```bash
  export TEAM_API_KEY=YOUR_API_KEY
  ```

  ```bash
  set TEAM_API_KEY=YOUR_API_KEY
  ```

  ```
  %env TEAM_API_KEY=YOUR_API_KEY
  ```



  Let’s see how we can use aixplain to run a machine translation model. The following example shows an [English to French translation model](https://platform.aixplain.com/discovery/model/61dc52976eb5634cf06e97cc).

  ```python
  from aixplain.factories import ModelFactory
  model = ModelFactory.get("61dc52976eb5634cf06e97cc") # Get the ID of a model from our platform.
  translation = model.run("This is a sample text") # Alternatively, you can input a public URL or provide a file path on your local machine.
  ```
  *Check out the [explore section](docs/user/user_doc.md#explore) of our guide on Models to get the ID of your desired model*



  * [Team API Key Guide](docs/user/api_setup.md)
  * [User Documentation](docs/user/user_doc.md)
  * [Developer Guide](docs/development/developer_guide.md)
  * [API Reference](https://docs.aixplain.com)
  * [Release notes](https://github.com/aixplain/aiXplain/releases)


  Raise issues for support in this repository.
  Pull requests are welcome!


  The **aiXtend** python package was renamed to **aiXplain** from the release v0.1.1.


pkgId: b2b76fef876fa467b46d35566dea97d79b849f924bb836775e3ae68ae1486708
name: python-aiagents4pharma-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for aiagents4pharma
url: https://pypi.org/project/aiagents4pharma/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiagents4pharma-1.4.0-1.src.rpm
location_href: Packages/python-aiagents4pharma-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  **Talk2BioModels** is an AI agent designed to facilitate interaction with mathematical models in systems biology. Systems biology models are critical in understanding complex biological mechanisms, but they’re often inaccessible to those without coding or mathematical expertise. Talk2BioModels simplifies this, enabling researchers to focus on analysis and interpretation rather than on programming. With Talk2BioModels, users can interact directly with these models through natural language. By simply asking questions or making requests, users can:
  - Forward simulation of both internal and open-source models (BioModels).
  - Adjust parameters within the model to simulate different conditions.
  - Query simulation results.

  **Talk2Cells** is being developed to provide direct access to and analysis of sequencing data, such as RNA-Seq or DNA-Seq, using natural language.

  **Talk2KnowledgeGraphs** is an agent designed to enable interaction with biological knowledge graphs (KGs). KGs integrate vast amounts of structured biological data into a format that highlights relationships between entities, such as proteins, genes, and diseases.


  - **Python 3.10+**
  - **Git**
  - Required libraries specified in `requirements.txt`


     ```bash
     pip install aiagents4pharma
     ```
  Check out the tutorials on each agent for detailed instrcutions.

  1. **Clone the repository:**
     ```bash
     git clone https://github.com/VirtualPatientEngine/AIAgents4Pharma
     cd AIAgents4Pharma
     ```
  2. **Install dependencies:**
     ```bash
     pip install -r requirements.txt
     ```
  3. **Initialize OPENAI_API_KEY**
     ```bash
     export OPENAI_API_KEY = ....
     ```
  4. **[Optional] Set up login credentials**
     ```bash
     vi .streamlit/secrets.toml
     ```
     and enter
     ```
     password='XXX'
     ```
     Please note that the passowrd will be same for all the users.
  5. **[Optional] Initialize LANGSMITH_API_KEY**
     ```bash
     export LANGCHAIN_TRACING_V2=true
     export LANGCHAIN_API_KEY=<your-api-key>
     ```
     Please note that this will create a new tracing project in your Langsmith
     account with the name `<user_name>@<uuid>`, where `user_name` is the name
     you provided in the previous step. If you skip the previous step, it will
     default to `default`. <uuid> will be the 128 bit unique ID created for the
     session.
  6. **Launch the app:**
     ```bash
     streamlit run app/frontend/streamlit_app.py
     ```


pkgId: 5c248b4123d896b95867af2a19a0dd02f996773230b5769af372bff79e1fcb8d
name: python-aichatlite-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for aichatlite
url: https://github.com/username/sa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aichatlite-0.2.8-1.src.rpm
location_href: Packages/python-aichatlite-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  Transform your AI interactions with omni-ai, an innovative open-source chatbot system that brings Claude-like capabilities to everyone using Hugging Face's most powerful open models. Built around the cutting-edge Qwen2.5-70B, our system delivers enterprise-grade conversational AI without the enterprise price tag.



  - 🧠 Powered by state-of-the-art Qwen2.5-70B model - the most capable open-source alternative to proprietary AI
  - 🎭 Implements Claude-inspired prompting techniques for human-like interactions
  - 🔗 Seamless integration with HuggingFace's ecosystem
  - 🎨 Beautiful artifact rendering similar to Claude's interface
  - 🌐 Built-in web search capabilities for real-time knowledge
  - 📚 Multiple specialist modes: Coding, Research, Analysis, and more
  - 💡 Smart context handling and conversation memory
  - 🚀 Fast response times with streaming output
  - 💰 completely FREE to use with open source models


  - 💻 Developers seeking a powerful coding assistant
  - 📊 Data scientists needing analysis help
  - 🔍 Researchers requiring smart search integration
  - 🎓 Students looking for learning support
  - 🏢 Teams wanting Claude-like features without the cost



  - 🎯 Multiple AI models support
  - 💬 Interactive chat interface
  - 🔍 Web search integration
  - 📱 Clean and responsive UI
  - 🎨 Beautiful artifact rendering
  - 🤝 Multiple agent types for different use cases



  ```bash
  pip install aichatlite
  ```



  Launch the UI with a single command:

  ```bash
  claude-chat
  ```

  This will start the web interface on port 8501.



  | Model Type | Description |
  |------------|-------------|
  | 🖥️ Coding | Qwen2.5-Coder-32B-Instruct - Specialized for programming tasks |
  | 🌐 General | Qwen2.5-72B-Instruct - Best for general-purpose use |
  | 🔮 Preview | QwQ-32B-Preview - Latest experimental features |
  | 💭 Conversational | Hermes-3-Llama-3.1-8B - Optimized for natural dialogue |
  | 📱 Mini | Phi-3.5-mini-instruct - Lightweight model for basic tasks |



  - QuestionAnswer: Direct response to queries
  - Reasoning: In-depth analytical responses
  - GoogleSearchAI: Web-enhanced responses
  - SearchAI: Alternative search implementation
  - GoogleSearch: Basic web search integration
  - DeepGoogleSearch: Advanced web research capabilities



  Here's how the interface looks in action:

  ![Basic Chat Interface](figs/v0.1.3_chatlite.png)
  ![Improved UI with Artifact](figs/render_with_artifact_improved_ui.png)



  - ✅ Feature 1: Integrate hugchat and launch UI
  - ✅ Feature 2: Web search integration (available in aichatlite-web-release branch)
  - 🔄 Feature 3: PDF Chat integration
  - 🔄 Feature 4: AI Researcher capabilities (arxiv, google scholar, etc.)




  Choose from different models based on your needs:
  - Use Coding model for programming tasks
  - General model for everyday queries
  - Preview model for testing new features
  - Mini model for quick, simple responses


  Different agents for different tasks:
  - QuestionAnswer: Quick, direct responses
  - Reasoning: Detailed analytical answers
  - Various search options for web-enhanced responses



  - "Qwen/Qwen2.5-72B-Instruct"
  - "Qwen/QwQ-32B-Preview"
  - "Qwen/Qwen2.5-Coder-32B-Instruct"
  - "NousResearch/Hermes-3-Llama-3.1-8B"
  - "microsoft/Phi-3.5-mini-instruct"
  - "meta-llama/Llama-3.1-8B-Instruct"
  - "meta-llama/Llama-3.2-1B-Instruct"
  - "meta-llama/Llama-3.2-3B-Instruct"
  - "01-ai/Yi-1.5-34B-Chat"
  - "codellama/CodeLlama-34b-Instruct-hf"
  - "google/gemma-1.1-7b-it"
  - "google/gemma-2-2b-it"
  - "google/gemma-2-9b-it"
  - "google/gemma-2b-it"
  - "HuggingFaceH4/starchat2-15b-v0.1"
  - "HuggingFaceH4/zephyr-7b-alpha"
  - "HuggingFaceH4/zephyr-7b-beta"
  - "meta-llama/Llama-2-7b-chat-hf"
  - "meta-llama/Meta-Llama-3-8B-Instruct"
  - "microsoft/DialoGPT-medium"
  - "microsoft/Phi-3-mini-4k-instruct"
  - "mistralai/Mistral-7B-Instruct-v0.2"
  - "mistralai/Mistral-7B-Instruct-v0.3"
  - "mistralai/Mixtral-8x7B-Instruct-v0.1"
  - "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO"
  - "Qwen/Qwen2.5-1.5B-Instruct"
  - "Qwen/Qwen2.5-3B-Instruct"
  - "tiiuae/falcon-7b-instruct"
  - "uschreiber/llama3.2"





  ![Chatbot Image](figs/v0.1.9.png)

  ![Chatbot Image](figs/v0.1.3_chatlite.png)

  ![Chatbot Image](figs/intial_render.png)

  ![Chatbot Image + Artifact](figs/render_with_artifact.png)

  ![Chatbot Image + Artifact After UI Improvement](figs/render_with_artifact_improved_ui.png)



  [Add your license information here]


pkgId: bb3dacd1d3cc0a3752b8c9122a846a53439d6e66754b53da02b3722dc25be4f0
name: python-aicmt-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for aicmt
url: https://github.com/versun/aicmt
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aicmt-0.0.1-1.src.rpm
location_href: Packages/python-aicmt-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [English](./README.md) | [中文](./README_CN.md)


  An AI-powered Git commit assistant that not only generates commit messages, but also automatically analyzes and splits your code changes into multiple well-organized commits following best practices.

  [![aicmt](https://asciinema.org/a/695352.svg)](https://asciinema.org/a/695352/?autoplay=1)



  - **Intelligent Change Splitting**: Unlike traditional commit message generators, aicmt analyzes your code changes and automatically splits them into logical, focused commits following Git best practices
  - **Flexible Control**: You can let AI decide the optimal number of commits, or specify exactly how many commits you want
  - **Focus on Coding**: Make all your changes freely, and let AI handle the commit organization - no need to worry about making perfect atomic commits while coding



  Requires Python 3.10 or higher.

  ```bash
  pip install aicmt
  ```



  In your git repository directory, run:
  ```bash
  aicmt --api-key <API_KEY> --model <MODEL> --base-url <OPENAI_BASE_URL>
  ```

  To specify the number of commits to generate(default: AI decides):
  ```bash
  aicmt --api-key <API_KEY> --model <MODEL> -n 3  # Split changes into 3 commits
  ```


  ```bash
  $ aicmt -h
  usage: aicmt [-h] [-v] [--api-key KEY] [--base-url URL] [--model MODEL] [-n N]

  <<< AICMT (AI Commit) - AI-powered Git commit assistant >>>

  options:
    -h, --help           show this help message and exit
    -v, --version        show program's version number and exit
    --api-key KEY        OpenAI API key for authentication
    --base-url URL       Custom API base URL (default: https://api.openai.com/v1)
    --model MODEL        AI model to use (default: gpt-4o-mini)
    -n, --num-commits N  Number of commits to generate (default: AI decides)
  ```



  1. Create configuration file `.aicmtrc`

  Reference the template file [`.aicmtrc.template`](./.aicmtrc.template)` and create `.aicmtrc` in your home directory.
  ```bash
  cp .aicmtrc.template ~/.aicmtrc
  ```
  You can also create `.aicmtrc` in the current directory, which will override the global configuration file (~/.aicmtrc)
  ```bash
  cd /path/to/git/repo
  touch .aicmtrc
  ```

  2. Add OpenAI API and other information in the configuration file.

  3. Enter your git repository directory and run the `aicmt` command to automatically analyze changes and generate commit messages.



  1. Clone the repository:
  ```bash
  git clone https://github.com/versun/aicmt.git
  ```

  2. Install dependencies:
  ```bash
  cd aicmt
  pip install ".[dev]"
  ```


  All code in this project is AI-generated, so if you encounter any problems, please first try asking AI for solutions (preferably using the claude-3.5-sonnet model).
  If the issue persists, please submit an issue, and I will consult AI to resolve it.



  Pull requests are welcome!


  I am deeply grateful to my amazing supporters and sponsors who have made my open source journey possible.
  <p align="center">
    <a href="https://github.com/versun/sponsors/">
      <img src='https://raw.githubusercontent.com/versun/sponsors/main/sponsors.svg'/>
    </a>
  </p>

  Become a Sponser on [Github](https://github.com/sponsors/versun) / [爱发电](https://afdian.com/@versun) / [微信](https://github.com/versun/sponsors/blob/b11431cb1302a4605f8e92447aaa061cbe704b68/wechat.jpg)



  [![Star History Chart](https://api.star-history.com/svg?repos=versun/aicmt&type=Date)](https://star-history.com/#versun/aicmt&Date)


pkgId: 909b68cacf69ac3c80337e64a88f189cf8fab0c9274b6c2b08e94d25e2106922
name: python-aidbox-logging-help
arch: noarch
version: 0.1.0b1
epoch: 0
release: 1
summary: Development documents and examples for aidbox-logging
url: https://pypi.org/project/aidbox-logging/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aidbox-logging-0.1.0b1-1.src.rpm
location_href: Packages/python-aidbox-logging-help-0.1.0b1-1.noarch.rpm
checksum_type: sha256
description:
  [![build status](https://github.com/beda-software/aidbox-logging-py/actions/workflows/main.yml/badge.svg)](https://github.com/beda-software/aidbox-logging-py/actions/workflows/main.yml)
  [![codecov](https://codecov.io/gh/beda-software/aidbox-logging-py/branch/master/graph/badge.svg)](https://codecov.io/gh/beda-software/aidbox-logging-py)
  [![pypi](https://img.shields.io/pypi/v/aidbox-logging.svg)](https://pypi.org/project/aidbox-logging)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Supported Python version](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/release/python-311/)


  Aidbox $loggy python logging handler with queue



  Install from pypi as `aidbox-logging`



  ```python
  from aidbox_logging import init_queued_aidbox_loggy_handler, enable_excepthook_logging


  logging.basicConfig(
      format="[s] [d] [s] s s",
      datefmt="%Y-%m-%d %H:%M:%SOURCE%z",
  )
  root_logger = logging.getLogger()
  root_logger.setLevel(logging.DEBUG)
  if env_config.loggy_url:
      loggy_handler = init_queued_aidbox_loggy_handler(
          env_config.loggy_url,
          app="lab-backend",
          version=f"{version.__version__}-{version.__build_commit_hash__}",
          meta={
              "env": env_config.lab_room_id,
          },
      )

      
      root_logger.addHandler(loggy_handler)

      
      logging.getLogger("gunicorn.error").addHandler(loggy_handler)

      
      enable_excepthook_logging()
  ```


pkgId: e66021e7099f262368db2b6a7396135cc2bf07844526551ffeda1d9762454f4d
name: python-aider-chat-help
arch: noarch
version: 0.69.0
epoch: 0
release: 1
summary: Development documents and examples for aider-chat
url: https://github.com/Aider-AI/aider
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aider-chat-0.69.0-1.src.rpm
location_href: Packages/python-aider-chat-help-0.69.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- Edit README.md, not index.md -->



  Aider lets you pair program with LLMs,
  to edit code in your local git repository.
  Start a new project or work with an existing git repo.
  Aider works best with GPT-4o & Claude 3.5 Sonnet and can
  [connect to almost any LLM](https://aider.chat/docs/llms.html).

  <!-- SCREENCAST START -->
  <p align="center">
    <img
      src="https://aider.chat/assets/screencast.svg"
      alt="aider screencast"
    >
  </p>
  <!-- SCREENCAST END -->

  <!-- VIDEO START
  <p align="center">
    <video style="max-width: 100%; height: auto;" autoplay loop muted playsinline>
      <source src="/assets/shell-cmds-small.mp4" type="video/mp4">
      Your browser does not support the video tag.
    </video>
  </p>
  VIDEO END -->

  <p align="center">
    <a href="https://discord.gg/Tv2uQnR88V">
      <img src="https://img.shields.io/badge/Join-Discord-blue.svg"/>
    </a>
    <a href="https://aider.chat/docs/install.html">
      <img src="https://img.shields.io/badge/Read-Docs-green.svg"/>
    </a>
  </p>


  <!--[[[cog


  cog.out(open("aider/website/_includes/get-started.md").read())
  ]]]-->

  You can get started quickly like this:

  ```bash
  python -m pip install -U aider-chat


  cd /to/your/git/repo


  export ANTHROPIC_API_KEY=your-key-goes-here
  aider


  export OPENAI_API_KEY=your-key-goes-here
  aider
  ```
  <!--[[[end]]]-->

  See the
  [installation instructions](https://aider.chat/docs/install.html)
  and other
  [documentation](https://aider.chat/docs/usage.html)
  for more details.



  - Run aider with the files you want to edit: `aider <file1> <file2> ...`
  - Ask for changes:
    - Add new features or test cases.
    - Describe a bug.
    - Paste in an error message or or GitHub issue URL.
    - Refactor code.
    - Update docs.
  - Aider will edit your files to complete your request.
  - Aider [automatically git commits](https://aider.chat/docs/git.html) changes with a sensible commit message.
  - Aider works with [most popular languages](https://aider.chat/docs/languages.html): python, javascript, typescript, php, html, css, and more...
  - Aider works best with GPT-4o & Claude 3.5 Sonnet and can [connect to almost any LLM](https://aider.chat/docs/llms.html).
  - Aider can edit multiple files at once for complex requests.
  - Aider uses a [map of your entire git repo](https://aider.chat/docs/repomap.html), which helps it work well in larger codebases.
  - Edit files in your editor while chatting with aider,
  and it will always use the latest version.
  Pair program with AI.
  - [Add images to the chat](https://aider.chat/docs/usage/images-urls.html) (GPT-4o, Claude 3.5 Sonnet, etc).
  - [Add URLs to the chat](https://aider.chat/docs/usage/images-urls.html) and aider will read their content.
  - [Code with your voice](https://aider.chat/docs/usage/voice.html).




  [Aider has one of the top scores on SWE Bench](https://aider.chat/2024/06/02/main-swe-bench.html).
  SWE Bench is a challenging software engineering benchmark where aider
  solved *real* GitHub issues from popular open source
  projects like django, scikitlearn, matplotlib, etc.



  - [Documentation](https://aider.chat/)
  - [Installation](https://aider.chat/docs/install.html)
  - [Usage](https://aider.chat/docs/usage.html)
  - [Tutorial videos](https://aider.chat/docs/usage/tutorials.html)
  - [Connecting to LLMs](https://aider.chat/docs/llms.html)
  - [Configuration](https://aider.chat/docs/config.html)
  - [Troubleshooting](https://aider.chat/docs/troubleshooting.html)
  - [LLM Leaderboards](https://aider.chat/docs/leaderboards/)
  - [GitHub](https://github.com/Aider-AI/aider)
  - [Discord](https://discord.gg/Tv2uQnR88V)
  - [Blog](https://aider.chat/blog/)




  - *The best free open source AI coding assistant.* -- [IndyDevDan](https://youtu.be/YALpX8oOn78)
  - *The best AI coding assistant so far.* -- [Matthew Berman](https://www.youtube.com/watch?v=df8afeb1FY8)
  - *Aider ... has easily quadrupled my coding productivity.* -- [SOLAR_FIELDS](https://news.ycombinator.com/item?id=36212100)
  - *It's a cool workflow... Aider's ergonomics are perfect for me.* -- [qup](https://news.ycombinator.com/item?id=38185326)
  - *It's really like having your senior developer live right in your Git repo - truly amazing!* -- [rappster](https://github.com/Aider-AI/aider/issues/124)
  - *What an amazing tool. It's incredible.* -- [valyagolev](https://github.com/Aider-AI/aider/issues/6#issue-1722897858)
  - *Aider is such an astounding thing!* -- [cgrothaus](https://github.com/Aider-AI/aider/issues/82#issuecomment-1631876700)
  - *It was WAY faster than I would be getting off the ground and making the first few working versions.* -- [Daniel Feldman](https://twitter.com/d_feldman/status/1662295077387923456)
  - *THANK YOU for Aider! It really feels like a glimpse into the future of coding.* -- [derwiki](https://news.ycombinator.com/item?id=38205643)
  - *It's just amazing.  It is freeing me to do things I felt were out my comfort zone before.* -- [Dougie](https://discord.com/channels/1131200896827654144/1174002618058678323/1174084556257775656)
  - *This project is stellar.* -- [funkytaco](https://github.com/Aider-AI/aider/issues/112#issuecomment-1637429008)
  - *Amazing project, definitely the best AI coding assistant I've used.* -- [joshuavial](https://github.com/Aider-AI/aider/issues/84)
  - *I absolutely love using Aider ... It makes software development feel so much lighter as an experience.* -- [principalideal0](https://discord.com/channels/1131200896827654144/1133421607499595858/1229689636012691468)
  - *I have been recovering from multiple shoulder surgeries ... and have used aider extensively. It has allowed me to continue productivity.* -- [codeninja](https://www.reddit.com/r/OpenAI/s/nmNwkHy1zG)
  - *I am an aider addict. I'm getting so much more work done, but in less time.* -- [dandandan](https://discord.com/channels/1131200896827654144/1131200896827654149/1135913253483069470)
  - *After wasting $100 on tokens trying to find something better, I'm back to Aider. It blows everything else out of the water hands down, there's no competition whatsoever.* -- [SystemSculpt](https://discord.com/channels/1131200896827654144/1131200896827654149/1178736602797846548)
  - *Aider is amazing, coupled with Sonnet 3.5 it’s quite mind blowing.* -- [Josh Dingus](https://discord.com/channels/1131200896827654144/1133060684540813372/1262374225298198548)
  - *Hands down, this is the best AI coding assistant tool so far.* -- [IndyDevDan](https://www.youtube.com/watch?v=MPYFPvxfGZs)
  - *[Aider] changed my daily coding workflows. It's mind-blowing how a single Python application can change your life.* -- [maledorak](https://discord.com/channels/1131200896827654144/1131200896827654149/1258453375620747264)
  - *Best agent for actual dev work in existing codebases.* -- [Nick Dobos](https://twitter.com/NickADobos/status/1690408967963652097?s=20)


pkgId: 9dfb048efd9bf9c33b06a4a8cbb69a4fa9fce125f000355e31a77ee4d35c907d
name: python-aider-install-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for aider-install
url: https://github.com/Aider-AI/aider-install
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aider-install-0.1.0-1.src.rpm
location_href: Packages/python-aider-install-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A streamlined installer for the [aider AI coding assistant](https://aider.chat).



  ```bash
  python -m pip install aider-install
  aider-install
  ```



  - Sets up aider and its dependencies in an isolated environment
  - Automatically installs Python 3.12 if not present
  - Uses [uv](https://docs.astral.sh/uv/) for fast, reliable Python package management
  - Zero configuration needed
  - Only 2 packages are installed in the original python environment: uv and aider-install.
  No other dependencies pollute your original python environment.



  - macOS, Linux, or Windows
  - Python 3.8+ (Python 3.12 will be installed if needed)



  1. Running `python -m pip install aider-install` installs:
    - The very minimal `aider-install` package, which provides the `aider-install` command.
    - The uv python package as its only dependency.
  2. Running `aider-install` does this:

  ```bash
  uv tool install --python python3.12 aider-chat
  uv tool update-shell
  ```



  - [Aider documentation](https://aider.chat)
  - [uv package manager](https://docs.astral.sh/uv/)



  For issues with the installer, please [open a GitHub issue](https://github.com/Aider-AI/aider/issues).
  For aider usage questions, see the [aider documentation](https://aider.chat).


pkgId: a72edf6fc0570bb25a9335a53df97a7d53f12adcbe63814589506461e0b15854
name: python-aidial-interceptors-sdk-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for aidial-interceptors-sdk
url: https://epam-rail.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aidial-interceptors-sdk-0.3.0-1.src.rpm
location_href: Packages/python-aidial-interceptors-sdk-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/aidial-interceptors-sdk.svg)](https://pypi.org/project/aidial-interceptors-sdk/)

  > [!IMPORTANT]
  > This package is in early development and subject to rapid changes. Breaking changes between versions are likely as the project evolves.



  The framework provides useful classes and helpers for creating DIAL Interceptors in Python for chat completion and embedding models.

  An interceptor could be thought of as a middleware that

  1. modifies an incoming DIAL request received from the client *(or it may leave it as is)*
  2. calls upstream DIAL application *(**the upstream** for short)* with the modified request
  3. modifies the response from the upstream *(or it may leave it as is)*
  4. returns the modified response to the client

  The upstream is encapsulated behind a special deployment id `interceptor`. This deployment id is resolved by the DIAL Core into an appropriate deployment id.

  Interceptors could be classified into the following categories:

  1. **Pre-interceptors** that only modify the incoming request from the client *(e.g. rejecting requests following certain criteria)*
  2. **Post-interceptors** that only modify the response received from the upstream *(e.g. censoring the response)*
  3. **Generic interceptors** that modify both the incoming request and the response from the upstream *(e.g. caching the responses)*

  To create chat completion interceptor one needs to implement instance of the class [ChatCompletionInterceptor](aidial_interceptors_sdk/chat_completion/base.py) and for embedding interceptor - [EmbeddingsInterceptor](aidial_interceptors_sdk/embeddings/base.py).

  See [example](aidial_interceptors_sdk/examples/interceptor/registry.py) interceptor implementations for more details.



  Copy `.env.example` to `.env` and customize it for your environment:

  |Variable|Default|Description|
  |---|---|---|
  |LOG_LEVEL|INFO|Log level. Use DEBUG for dev purposes and INFO in prod|
  |WEB_CONCURRENCY|1|Number of workers for the server|
  |DIAL_URL||The URL of the DIAL Core server|



  This project uses [Python>=3.11](https://www.python.org/downloads/) and [Poetry>=1.6.1](https://python-poetry.org/) as a dependency manager.

  Check out Poetry's [documentation on how to install it](https://python-poetry.org/docs/#installation) on your system before proceeding.

  To install requirements:

  ```sh
  poetry install
  ```

  This will install all requirements for running the package, linting, formatting and tests.



  The recommended IDE is [VSCode](https://code.visualstudio.com/).
  Open the project in VSCode and install the recommended extensions.

  The VSCode is configured to use PEP-8 compatible formatter [Black](https://black.readthedocs.io/en/stable/index.html).

  Alternatively you can use [PyCharm](https://www.jetbrains.com/pycharm/).

  Set-up the Black formatter for PyCharm [manually](https://black.readthedocs.io/en/stable/integrations/editors.html#pycharm-intellij-idea) or
  install PyCharm>=2023.2 with [built-in Black support](https://blog.jetbrains.com/pycharm/2023/07/2023-2/#black).



  As of now, Windows distributions do not include the make tool. To run make commands, the tool can be installed using
  the following command (since [Windows 10](https://learn.microsoft.com/en-us/windows/package-manager/winget/)):

  ```sh
  winget install GnuWin32.Make
  ```

  For convenience, the tool folder can be added to the PATH environment variable as `C:\Program Files (x86)\GnuWin32\bin`.
  The command definitions inside Makefile should be cross-platform to keep the development environment setup simple.



  To run the linting before committing:

  ```sh
  make lint
  ```

  To auto-fix formatting issues run:

  ```sh
  make format
  ```



  To run unit tests:

  ```sh
  make test
  ```



  To remove the virtual environment and build artifacts:

  ```sh
  make clean
  ```



  The repository also provides examples of various DIAL Interceptors all packed into a DIAL service.

  Keep in mind, that the following example interceptors aren't ready for a production use.
  They are provided solely as examples to demonstrate basic use cases of interceptors. Use at your discretion.



  |Interceptor name|Category|Description|
  |---|---|---|
  |reply-as-pirate|Pre|Injects systems prompt `Reply as a pirate` to the request|
  |reject-external-links|Pre|Rejects any URL in DIAL attachments which do not point to DIAL Core storage|
  |reject-blacklisted-words|Generic|Rejects the request if it contains any blacklisted words|
  |image-watermark|Post|Stamps "EPAM DIAL" watermark on all image attachments in the response. Demonstrates how to work with files stored on DIAL File Storage.|
  |statistics-reporter|Post|Collects statistics on the response stream *(tokens/sec, finish reason, completion tokens etc)* and reports it in a new stage when response is finished|
  |pii-anonymizer|Generic|Anonymizes any PII in the request, calls the upstream, deanonymizes the response|
  |replicator:N|Generic|Calls the upstream N times and combines the N response into a single response. Could be useful for stabilization of model's output, since certain models aren't deterministic.|
  |cache|Generic|Caches incoming chat completion requests. **Not ready for production use. Use at your discretion**|
  |no-op|Generic|No-op interceptor - does not modify the request or the response, simply proxies the upstream|



  |Interceptor name|Category|Description|
  |---|---|---|
  |reject-blacklisted-words|Pre|Rejects the request if it contains any blacklisted words|
  |normalize-vector|Post|Normalizes the vector in the response|
  |project-vector:N|Post|Changes the dimensionality of the vectors in the response to N, where N is an integer path parameter.|
  |no-op|Generic|No-op interceptor - does not modify the request or the response, simply proxies the upstream|



  Copy `.env.example` to `.env` and customize it for your environment:

  |Variable|Default|Description|
  |---|---|---|
  |PII_ANONYMIZER_LABELS_TO_REDACT|PERSON,ORG,GPE,PRODUCT|Comma-separated list of spaCy entity types to redact. Find the full list of entities [here](https://github.com/explosion/spacy-models/blob/e46017f5c8241096c1b30fae080f0e0709c8038c/meta/en_core_web_sm-3.7.0.json#L121-L140).|





  To run the server with examples using pip:

  ```sh
  pip install uvicorn python-dotenv "aidial-interceptors-sdk[examples]"
  echo "DIAL_URL=URL" > .env
  uvicorn "aidial_interceptors_sdk.examples.app:app" --host "0.0.0.0" --port 5000 --env-file ./.env
  ```

  Don't forget to set the appropriate `DIAL_URL` in the `.env` file.

  The command will start the server on `http://localhost:5000` exposing endpoints for each of the interceptors like the following:

  - `http://localhost:5000/openai/deployments/pii-anonymizer/chat/completions`
  - `http://localhost:5000/openai/deployments/normalize-vector/embeddings`



  First clone the repository:

  ```sh
  git clone https://github.com/epam/ai-dial-interceptors-sdk.git
  cd ai-dial-interceptors-sdk
  echo "DIAL_URL=URL" > .env
  ```

  Then run dev server with examples:

  ```sh
  make examples_serve
  ```

  Or run the server from Docker container:

  ```sh
  make examples_docker_serve
  ```



  The interceptor endpoints are defined in the `interceptors` section of the DIAL Core configuration like this:

  ```json
  {
      "interceptors": {
          "chat-reply-as-pirate": {
              "endpoint": "${INTERCEPTOR_SERVICE_URL}/openai/deployments/reply-as-pirate/chat/completions"
          },
          "chat-statistics-reporter": {
              "endpoint": "${INTERCEPTOR_SERVICE_URL}/openai/deployments/statistics-reporter/chat/completions"
          }
      }
  }
  ```

  where `INTERCEPTOR_SERVICE_URL` is the URL of the interceptor service, which is `http://localhost:5000` when run locally, or the interceptor service URL when deployed within Kubernetes.

  The declared interceptors could be then attached to particular models and applications:

  ```json
  {
      "models": {
          "anthropic.claude-v3-haiku": {
              "type": "chat",
              "iconUrl": "anthropic.svg",
              "endpoint": "${BEDROCK_ADAPTER_SERVICE_URL}/openai/deployments/anthropic.claude-3-haiku-20240307-v1:0/chat/completions",
              "interceptors": [
                  "chat-statistics-reporter",
                  "chat-reply-as-pirate"
              ]
          }
      }
  }
  ```

  Make sure that

  1. chat completion interceptors are only used in chat models or application,
  2. embeddings interceptors are only used in embeddings models.

  The stack of interceptors in DIAL works similarly to a stack of middlewares in Express.js or Django:

  ```txt
  Client -> (original request) ->
    Interceptor 1 -> (modified request #1) ->
      Interceptor 2 -> (modified request #2) ->
        Upstream -> (original response) ->
      Interceptor 2 -> (modified response #1) ->
    Interceptor 1 -> (modified response #2) ->
  Client
  ```

  **Every** request/response in the diagram above goes through the DIAL Core. This is hidden from the diagram for brevity.


pkgId: 6b5c1fc7bb8fbc6f62d9040a463fece489420d79d99325d4e05d43a9d7a4a654
name: python-aiida-pythonjob-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for aiida-pythonjob
url: https://pypi.org/project/aiida-pythonjob/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiida-pythonjob-0.1.5-1.src.rpm
location_href: Packages/python-aiida-pythonjob-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aiida-pythonjob.svg)](https://badge.fury.io/py/aiida-pythonjob)
  [![Unit test](https://github.com/aiidateam/aiida-pythonjob/actions/workflows/ci.yml/badge.svg)](https://github.com/aiidateam/aiida-pythonjob/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/aiidateam/aiida-pythonjob/branch/main/graph/badge.svg)](https://codecov.io/gh/aiidateam/aiida-pythonjob)
  [![Docs status](https://readthedocs.org/projects/aiida-pythonjob/badge)](http://aiida-pythonjob.readthedocs.io/)

  `PythonJob` allows users to run Python functions on a remote computer. It is designed to enable users from non-AiiDA communities to run their Python functions remotely and construct workflows with checkpoints, maintaining all data provenance. For instance, users can use ASE's calculator to run a DFT calculation on a remote computer directly.



  1. **Remote Execution**: Seamlessly run Python functions on a remote computer.
  2. **User-Friendly**: Designed for users who are not familiar with AiiDA, simplifying the process of remote execution.
  3. **Workflow Management**: Construct workflows using WorkGraph with checkpoints, ensuring that intermediate states and results are preserved.
  4. **Data Provenance**: Maintain comprehensive data provenance, tracking the full history and transformations of data.





  ```console
      pip install aiida-pythonjob
  ```

  To install the latest version from source, first clone the repository and then install using `pip`:

  ```console
  git clone https://github.com/aiidateam/aiida-pythonjob
  cd aiida-pythonjob
  pip install -e .
  ```



  Explore the comprehensive [documentation](https://aiida-pythonjob.readthedocs.io/en/latest/) to discover all the features and capabilities of AiiDA PythonJob.



  [MIT](http://opensource.org/licenses/MIT)

rpm_license:
  MIT License  Copyright (c) 2024 AiiDA team  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: f23317efc6f467a564a7275ba99740e11c97580962dce1782f0a3a6e20ec14e8
name: python-aiida-workgraph-help
arch: noarch
version: 0.4.10
epoch: 0
release: 1
summary: Development documents and examples for aiida-workgraph
url: https://pypi.org/project/aiida-workgraph/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiida-workgraph-0.4.10-1.src.rpm
location_href: Packages/python-aiida-workgraph-help-0.4.10-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aiida-workgraph.svg)](https://badge.fury.io/py/aiida-workgraph)
  [![Unit test](https://github.com/aiidateam/aiida-workgraph/actions/workflows/ci.yaml/badge.svg)](https://github.com/aiidateam/aiida-workgraph/actions/workflows/ci.yaml)
  [![codecov](https://codecov.io/gh/aiidateam/aiida-workgraph/branch/main/graph/badge.svg)](https://codecov.io/gh/aiidateam/aiida-workgraph)
  [![Docs status](https://readthedocs.org/projects/aiida-workgraph/badge)](http://aiida-workgraph.readthedocs.io/)

  Efficiently design and manage flexible workflows with AiiDA, featuring an interactive GUI, checkpoints, provenance tracking, error-resistant, and remote execution capabilities.





  ```console
      pip install aiida-workgraph
  ```

  To install the latest version from source, first clone the repository and then install using `pip`:

  ```console
  git clone https://github.com/aiidateam/aiida-workgraph
  cd aiida-workgraph
  pip install -e .
  ```



  Explore the comprehensive [documentation](https://aiida-workgraph.readthedocs.io/en/latest/) to discover all the features and capabilities of AiiDA Workgraph.


  Visit the [Workgraph Collections repository](https://github.com/superstar54/workgraph-collections) to see demonstrations of how to utilize AiiDA Workgraph for different computational codes.


  Suppose we want to calculate ```(x + y) * z ``` in two steps. First, add `x` and `y`, then multiply the result with `z`.

  ```python
  from aiida_workgraph import WorkGraph, task


  @task.calcfunction
  def add(x, y):
      return x + y


  @task.calcfunction
  def multiply(x, y):
      return x*y


  wg = WorkGraph("test_add_multiply")
  wg.add_task(add, name="add1")
  wg.add_task(multiply, name="multiply1")
  wg.add_link(wg.tasks.add1.outputs.result, wg.tasks.multiply1.inputs.x)

  ```

  Prepare inputs and run the workflow:

  ```python
  from aiida import load_profile

  load_profile()

  wg.run(inputs = {"add1": {"x": 2, "y": 3}, "multiply1": {"y": 4}})
  print("Result of multiply1 is", wg.tasks.multiply1.outputs.result.value)
  ```

  To use the web ui, first install the web ui package:
  ```console
  pip install aiida-workgraph-web-ui
  ```
  Then, start the web app with the following command:
  ```console

  workgraph web start
  ```

  Then visit the page http://127.0.0.1:8000/workgraph, you should find a `first_workflow` WorkGraph, click the pk and view the WorkGraph.

  <img src="docs/source/_static/images/first-workflow.png" />


  One can also generate the node graph from the process:
  ```console
  verdi node generate pk
  ```

  <img src="docs/source/_static/images/add_multiply.png"/>





  To contribute to this repository, please enable pre-commit so the code in commits are conform to the standards.
  ```console
  pip install -e .[tests,pre-commit]
  pre-commit install
  ```


  [MIT](http://opensource.org/licenses/MIT)


pkgId: a52a2e4997e3198071f2861969ac3c7b75b67f54b3eea3daa5da7095f216687f
name: python-ailite-legacy-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for ailite-legacy
url: https://github.com/yourusername/pyopengenai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ailite-legacy-0.0.1-1.src.rpm
location_href: Packages/python-ailite-legacy-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A lightweight Python interface for AI model interactions through Hugging Face's infrastructure.



  ```bash
  pip install ailite
  ```





  Launch your own API server:

  ```python
  from ailite import serve


  serve()
  ```



  The simplest way to get started:

  ```python
  from ailite import ai
  response = ai("Explain quantum computing")
  print(response)
  ```

  ```python
  from ailite import ai
  response = ai(
      "Explain quantum computing",
      model="nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
      conversation=False
  )
  ```

  ```python
  from ailite import ai

  for chunk in ai(
      "Write a story about space",
      stream=True
  ):
      print(chunk, end="")
  ```




  For more control over interactions:

  ```python
  from ailite import HUGPIClient

  client = HUGPIClient(
      api_key="your_email@gmail.com_your_password",
      model="nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
      system_prompt="You are a helpful assistant..."
  )


  response = client.messages.create(
      prompt="What is the theory of relativity?",
      conversation=True
  )
  print(response.content[0]["text"])


  messages = [
      {"role": "user", "content": "Hi, how are you?"},
      {"role": "assistant", "content": "I'm doing well, how can I help?"},
      {"role": "user", "content": "Tell me about AI"}
  ]
  response = client.messages.create(messages=messages)
  ```



  For direct model interactions:

  ```python
  from ailite import HUGPiLLM

  llm = HUGPiLLM(
      hf_email="your_email@gmail.com",
      hf_password="your_password",
      default_llm=3,  # Model index
      system_prompt="Custom system instructions here"
  )

  response = llm.generate("Explain machine learning")
  ```



  ```
  fastapi>=0.68.0
  pydantic>=1.8.0
  uvicorn>=0.15.0
  requests>=2.26.0
  ```



  MIT License - see LICENSE file for details.


pkgId: e2908d38e5352d36613a0c0e10378bfb56c7dfd8005c87ce983313f51223752b
name: python-ailitellm-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for ailitellm
url: https://github.com/yourusername/pyopengenai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ailitellm-0.1.8-1.src.rpm
location_href: Packages/python-ailitellm-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ailitellm.svg)](https://badge.fury.io/py/ailitellm)
  [![Downloads](https://static.pepy.tech/badge/ailitellm)](https://pepy.tech/project/ailitellm)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
  [![Documentation Status](https://readthedocs.org/projects/ailitellm/badge/?version=latest)](https://ailitellm.readthedocs.io/en/latest/?badge=latest)
  [![GitHub issues](https://img.shields.io/github/issues/yourusername/ailitellm)](https://github.com/yourusername/ailitellm/issues)
  [![GitHub stars](https://img.shields.io/github/stars/yourusername/ailitellm)](https://github.com/yourusername/ailitellm/stargazers)

  AILiteLLM is a lightweight Python wrapper around the Hugging Face Inference API that provides OpenAI-like interface for various open-source language models. It makes it easy to use powerful open-source models with an interface familiar to OpenAI developers.


  - PyPI: [https://pypi.org/project/ailitellm/](https://pypi.org/project/ailitellm/)
  - Documentation: [https://ailitellm.readthedocs.io/](https://ailitellm.readthedocs.io/)
  - Source Code: [https://github.com/yourusername/ailitellm](https://github.com/yourusername/ailitellm)
  - Issue Tracker: [https://github.com/yourusername/ailitellm/issues](https://github.com/yourusername/ailitellm/issues)



  - OpenAI-compatible interface
  - Support for multiple Hugging Face models
  - Stream responses support
  - Function calling capabilities
  - Full typing support
  - Easy model switching



  From PyPI:
  ```bash
  pip install ailitellm
  ```

  From source:
  ```bash
  git clone https://github.com/yourusername/ailitellm.git
  cd ailitellm
  pip install -e .
  ```

  Development installation:
  ```bash
  pip install -e ".[dev]"
  ```



  ```python
  from ailitellm import ai, ailite_model


  response = ai("What is the capital of France?")
  print(response.choices[0].message.content)


  response = ai(
      "Explain quantum computing",
      model=ailite_model("Qwen/Qwen2.5-72B-Instruct")
  )
  ```



  AILiteLLM supports the following models:

  - `Qwen/Qwen2.5-72B-Instruct` - Large general purpose model
  - `Qwen/QwQ-32B-Preview` - Preview version of QwQ model
  - `Qwen/Qwen2.5-Coder-32B-Instruct` - Specialized for coding tasks
  - `NousResearch/Hermes-3-Llama-3.1-8B` - Efficient general purpose model
  - `microsoft/Phi-3.5-mini-instruct` - Lightweight instruction-following model





  ```python
  messages = [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Tell me a joke about programming."}
  ]

  response = ai(messages)
  ```



  ```python
  for chunk in ai("Write a poem about AI", stream=True):
      print(chunk.choices[0].delta.content, end="")
  ```



  ```python
  def get_weather(location: str, unit: str = "celsius") -> str:
      """Get the weather for a location"""
      pass

  response = ai(
      "What's the weather in London?",
      tools=[get_weather],
      tool_choice="auto"
  )
  ```



  ```python
  response = ai(
      "Generate a creative story",
      temperature=0.8,
      max_tokens=500,
      top_p=0.9,
      presence_penalty=0.6
  )
  ```



  ```python
  from ailitellm import AILite

  custom_client = AILite(
      base_url="your_custom_endpoint",
      api_key="your_api_key"
  )
  ```



  ```python
  try:
      response = ai("Your prompt here")
  except Exception as e:
      print(f"An error occurred: {e}")
  ```







  Main interface for generating completions.

  Key parameters:
  - `messages_or_prompt`: List of messages or string prompt
  - `model`: Model to use (default: "Qwen/Qwen2.5-72B-Instruct")
  - `temperature`: Sampling temperature (default: 0)
  - `max_tokens`: Maximum tokens to generate
  - `stream`: Enable streaming responses
  - `tools`: List of functions for tool calling
  - See source code for full list of parameters



  Helper function to specify model type with proper type checking.





  Custom client class extending OpenAI's base client.



  To set up the development environment:

  ```bash

  git clone https://github.com/yourusername/ailitellm.git
  cd ailitellm


  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate


  pip install -e ".[dev]"


  pytest tests/
  ```



  - Python >= 3.8
  - openai >= 1.0.0
  - httpx
  - typing-extensions



  Contributions are welcome! Please feel free to submit a Pull Request. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.



  If you use AILiteLLM in your research, please cite:

  ```bibtex
  @software{ailitellm2024,
    author = {Your Name},
    title = {AILiteLLM: OpenAI-compatible Interface for Hugging Face Models},
    year = {2024},
    publisher = {GitHub},
    url = {https://github.com/yourusername/ailitellm}
  }
  ```



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



  - OpenAI for the API interface design
  - Hugging Face for model hosting and inference API
  - All model creators and contributors



  - GitHub Issues: [https://github.com/yourusername/ailitellm/issues](https://github.com/yourusername/ailitellm/issues)
  - Email: your.email@example.com
  - Twitter: [@yourusername](https://twitter.com/yourusername)


pkgId: bd7e6218f2c50bb76c66af7479d425b3203650ae6bc74201420ccd2445fd7e1f
name: python-aiml-dsce-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for aiml-dsce
url: https://pypi.org/project/aiml-dsce/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aiml-dsce-1.0.0-1.src.rpm
location_href: Packages/python-aiml-dsce-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This package contains a collection of Python programs that implement various AI and ML algorithms.



  To install the package, you can use:

  ```bash
  pip install aiml_lab
  ```


pkgId: 6d1a78aff0bc9d3e55f6e466c41ae9e5677e1743f61bbc335a38373da2604e3f
name: python-aims-convert-help
arch: noarch
version: 2.3
epoch: 0
release: 1
summary: Development documents and examples for aims-convert
url: https://github.com/JonHurst/aims-convert
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aims-convert-2.3-1.src.rpm
location_href: Packages/python-aims-convert-help-2.3-1.noarch.rpm
checksum_type: sha256
description:
  This will primarily be of interest to easyJet pilots. It extracts data from a
  reports that can be downloaded from AIMS. Pilots from other airlines that use
  AIMS *may* also find this useful — it has only been tested against the files
  from easyJet’s version of AIMS (as that is all that I have access to), so its
  utility will depend on whether whatever version is being used by your airline
  produces sufficiently similar output.

  As well as extracting the data, a night flying calculation is carried out.

  The three main formats that the data can be extracted to are electronic Flight
  Journal (eFJ), iCalendar and CSV.

  An eFJ is a text file that can be used to store personal flight data in an
  intuitive non-tabular form. Full details of the format of this text file can be
  found at <https://hursts.org.uk/efjdocs/format.html>, and an online tool
  capable of converting this format to an FCL.050 compliant logbook in HTML
  format can be found at <https://hursts.org.uk/efj>.

  The iCalendar format can be imported into most calendar applications. There is
  an option to include full day events such as days off. This is useful for
  managing and sharing your future roster.

  The CSV format is for keeping logbook data in a spreadsheet.

  The package provides entry points for a command line interface, a Tk based
  graphical interface and an AWS lambda function. The AWS function is hooked up
  to a website at <https://hursts.org.uk/aims>, which requires no installation,
  just a browser. The other two interfaces require the installation of a Python
  interpreter.


pkgId: dc3900dfbade241ac727dff02666a06a4b35ee2f67849ff2f0b753b516e0c839
name: python-aind-behavior-video-transformation-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for aind-behavior-video-transformation
url: https://pypi.org/project/aind-behavior-video-transformation/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aind-behavior-video-transformation-0.1.6-1.src.rpm
location_href: Packages/python-aind-behavior-video-transformation-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
  ![Code Style](https://img.shields.io/badge/code%20style-black-black)
  [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
  ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-93%25-brightgreen?logo=codecov)
  ![Python](https://img.shields.io/badge/python->=3.10-blue?logo=python)

  This project is used to encode behavior videos and, depending on the user
  request, will compress those videos while ensuring that they are formatted for
  correct display across many devices. This may include common image
  preprocessing steps, such as gamma encoding, that are necessary for correct
  display, but have to be done post-hoc for our behavior videos.



  This will attempt to compress videos so that the results:

  * Retain the majority of the detail of the input video
  * Take up as little space as possible for a target amount of visual detail
  * Are in a format that can be widely viewed across devices, and streamed by
    browsers
  * Have pixel data in a color space that most players can properly display

  This video compression is often lossy, and the original videos are not kept, so
  this library will attempt to produce the highest-quality video for a target
  compression ratio. The _speed_ of this compression is strictly secondary to the
  _quality_ of the compression, as measured by the visual detail retained and the
  compression ratio. See
  [this section](#brief-benchmarks-on-video-compression-with-cpu-based-encoders-and-gpu-based-encoders)
  for more details.


  Additionally, this package should provide an easy to use interface that:

  * Presents users with a curated set of compression settings, which have been
    rigorously tested in terms of their visual quality using perception-based
    metrics like VMAF.
  * Allow users to also provide their own compression settings, if they have
    specific requirements



  * Sacrifice the visual fidelity of videos in order to decrease encoding time.



  A surprising fact is that video encoders implementing the same algorithm, but
  written for different compute resources do _not_ have the same visual
  performance; for a given compression ratio, or similar settings, they do not
  retain the same amount of visual detail. This is also true for different presets
  of the same encoder and compute resource even if the other settings are
  identical. For example, the presets `-preset fast` and `-preset veryslow` of the
  encoder `libx264` produce videos with the same compression ratio, but differing
  visual quality.

  This can be seen in the plot below, where the GPU encoder and CPU encoders
  retain different amounts of visual detail, as assessed with visual
  perception-based metric
  [VMAF](https://en.wikipedia.org/wiki/Video_Multimethod_Assessment_Fusion). Also
  note the difference between presets for the same encoder and compute resource:
  _CPU Fast_ and _CPU Slow_.

  ![visual performance vs compress ratio](/assets/compression-vs-quality.png)

  This figure shows that for compression ratios greater than 100, it often makes
  sense to take your time and use a slow preset of a CPU-based encoder to retain
  as much visual information for a given amount of compression.

  While it may be tempting to select a faster preset, or faster compute resource
  like GPU for dramatic speedups shown below, doing will degrade the quality of
  the resulting video.

  ![throughput vs compress ratio](/assets/compression-vs-speed.png)

  Because the output of this package are permanent video artifacts, the
  compression is lossy, and the intent is to delete the original, taking the CPU
  time to produce the highest quality video possible might well be worth it.


   - The BehaviorVideoJob.run_job method in the transform_videos should be the
     primary method to call for processing video files.
   - On a merge to main, this package will be published as a singularity
     container, which can easily be run on a SLURM cluster.


  In the same directory as the Dockerfile, run
  ```bash
  docker build -t aind-behavior-video-transformation-local .
  ```

  Now a docker container can be run. You may need to change the mount locations and file permissions:
  ```bash
  docker run -v /home/local_videos/input_source:/mnt/input_source -v /home/local_videos/output_directory:/mnt/output_directory aind-behavior-video-transformation-local python -m aind_behavior_video_transformation.etl --job-settings '{"compression_requested": {"compression_enum": "gamma fix colorspace"}, "parallel_compression": true, "input_source": "/mnt/input_source", "output_directory": "/mnt/output_directory"}'
  ```



  To develop the code, run
  ```bash
  pip install -e .[dev]
  ```





  There are several libraries used to run linters, check documentation, and run tests.

  - Please test your changes using the **coverage** library, which will run the tests and log a coverage report:

  ```bash
  coverage run -m unittest discover && coverage report
  ```

  - Use **interrogate** to check that modules, methods, etc. have been documented thoroughly:

  ```bash
  interrogate .
  ```

  - Use **flake8** to check that code is up to standards (no unused imports, etc.):
  ```bash
  flake8 .
  ```

  - Use **black** to automatically format the code into PEP standards:
  ```bash
  black .
  ```

  - Use **isort** to automatically sort import statements:
  ```bash
  isort .
  ```



  For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use [Angular](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit) style for commit messages. Roughly, they should follow the pattern:
  ```text
  <type>(<scope>): <short summary>
  ```

  where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:

  - **build**: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
  - **ci**: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
  - **docs**: Documentation only changes
  - **feat**: A new feature
  - **fix**: A bugfix
  - **perf**: A code change that improves performance
  - **refactor**: A code change that neither fixes a bug nor adds a feature
  - **test**: Adding missing tests or correcting existing tests



  The table below, from [semantic release](https://github.com/semantic-release/semantic-release), shows which commit message gets you which release type when `semantic-release` runs (using the default configuration):

  | Commit message                                                                                                                                                                                   | Release type                                                                                                    |
  | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
  | `fix(pencil): stop graphite breaking when too much pressure applied`                                                                                                                             | ~~Patch~~ Fix Release, Default release                                                                          |
  | `feat(pencil): add 'graphiteWidth' option`                                                                                                                                                       | ~~Minor~~ Feature Release                                                                                       |
  | `perf(pencil): remove graphiteWidth option`<br><br>`BREAKING CHANGE: The graphiteWidth option has been removed.`<br>`The default graphite width of 10mm is always used for performance reasons.` | ~~Major~~ Breaking Release <br /> (Note that the `BREAKING CHANGE: ` token must be in the footer of the commit) |


  To generate the rst files source files for documentation, run
  ```bash
  sphinx-apidoc -o doc_template/source/ src
  ```
  Then to create the documentation HTML files, run
  ```bash
  sphinx-build -b html doc_template/source/ doc_template/build/html
  ```
  More info on sphinx installation can be found [here](https://www.sphinx-doc.org/en/master/usage/installation.html).


